depa-actor 0.1.2 → 0.2.0

package/src/execution/commandDeque.ts

@@ -0,0 +1,656 @@
+export type CommandDequeId = string;
+
+export interface CommandDequeItem<TCommand> {
+  id: string;
+  command: TCommand;
+  insertedAt: number;
+  order: number;
+}
+
+export interface CommandDequeState<TCommand> {
+  id: CommandDequeId;
+  lane?: string;
+  priority: number;
+  items: CommandDequeItem<TCommand>[];
+}
+
+export interface CommandDequeGroupState<TCommand> {
+  deques: Record<CommandDequeId, CommandDequeState<TCommand>>;
+  sequence: number;
+}
+
+export interface CommandDequeOptions {
+  id?: CommandDequeId;
+  lane?: string;
+  priority?: number;
+  now?: () => number;
+  idFactory?: (args: { sequence: number; dequeId: CommandDequeId }) => string;
+}
+
+export interface PushCommandOptions {
+  id?: string;
+  insertedAt?: number;
+}
+
+export interface CommandDeque<TCommand> {
+  readonly id: CommandDequeId;
+  pushBack(command: TCommand, options?: PushCommandOptions): CommandDequeItem<TCommand>;
+  pushFront(command: TCommand, options?: PushCommandOptions): CommandDequeItem<TCommand>;
+  peekNext(): CommandDequeItem<TCommand> | undefined;
+  popNext(): CommandDequeItem<TCommand> | undefined;
+  peekFront(): CommandDequeItem<TCommand> | undefined;
+  peekBack(): CommandDequeItem<TCommand> | undefined;
+  popFront(): CommandDequeItem<TCommand> | undefined;
+  popBack(): CommandDequeItem<TCommand> | undefined;
+  listItems(): CommandDequeItem<TCommand>[];
+  getItem(id: string): CommandDequeItem<TCommand> | undefined;
+  nextAfter(itemId: string): CommandDequeItem<TCommand> | undefined;
+  prevBefore(itemId: string): CommandDequeItem<TCommand> | undefined;
+  drain(): CommandDequeItem<TCommand>[];
+  drainWhere(predicate: (item: CommandDequeItem<TCommand>) => boolean): CommandDequeItem<TCommand>[];
+  hasPending(): boolean;
+  snapshot(): CommandDequeState<TCommand>;
+}
+
+export interface CommandDequeSelection {
+  dequeId: CommandDequeId;
+  itemId: string;
+}
+
+export type CommandDequeSelector<TCommand, TRuntimeState> = (args: {
+  group: CommandDequeGroupState<TCommand>;
+  runtimeState: TRuntimeState;
+}) => CommandDequeSelection | undefined;
+
+export interface SelectedCommandDequeItem<TCommand> extends CommandDequeSelection {
+  deque: CommandDequeState<TCommand>;
+  item: CommandDequeItem<TCommand>;
+}
+
+export interface CommandDequeDefinition {
+  id: CommandDequeId;
+  lane?: string;
+  priority: number;
+}
+
+export interface CommandDequeGroupOptions<TCommand, TRuntimeState> {
+  deques?: CommandDequeDefinition[];
+  now?: () => number;
+  idFactory?: (args: { sequence: number; dequeId: CommandDequeId }) => string;
+  selector?: CommandDequeSelector<TCommand, TRuntimeState>;
+}
+
+export interface PushCommandToDequeOptions extends PushCommandOptions {
+  dequeId: CommandDequeId;
+}
+
+export interface CommandDequeGroup<TCommand, TRuntimeState = unknown> {
+  getDeque(dequeId: CommandDequeId): CommandDeque<TCommand>;
+  ensureDeque(definition: CommandDequeDefinition): CommandDeque<TCommand>;
+  pushBack(command: TCommand, options: PushCommandToDequeOptions): CommandDequeItem<TCommand>;
+  pushFront(command: TCommand, options: PushCommandToDequeOptions): CommandDequeItem<TCommand>;
+  selectNext(runtimeState: TRuntimeState, selector?: CommandDequeSelector<TCommand, TRuntimeState>): SelectedCommandDequeItem<TCommand> | undefined;
+  popSelected(selection: CommandDequeSelection): SelectedCommandDequeItem<TCommand> | undefined;
+  takeNext(runtimeState: TRuntimeState, selector?: CommandDequeSelector<TCommand, TRuntimeState>): SelectedCommandDequeItem<TCommand> | undefined;
+  drainDeque(dequeId: CommandDequeId): CommandDequeItem<TCommand>[];
+  drainWhereDeque(
+    dequeId: CommandDequeId,
+    predicate: (item: CommandDequeItem<TCommand>) => boolean,
+  ): CommandDequeItem<TCommand>[];
+  listDequeIds(): CommandDequeId[];
+  snapshot(): CommandDequeGroupState<TCommand>;
+}
+
+export interface CommandDequeGroupMutationResult<TCommand> {
+  state: CommandDequeGroupState<TCommand>;
+  item?: CommandDequeItem<TCommand>;
+  items?: CommandDequeItem<TCommand>[];
+  selection?: SelectedCommandDequeItem<TCommand>;
+}
+
+const DEFAULT_DEQUE_ID = 'default';
+const DEFAULT_PRIORITY = 100;
+
+class SingleCommandDeque<TCommand> implements CommandDeque<TCommand> {
+  private readonly state: CommandDequeState<TCommand>;
+  private sequence: number;
+  private readonly now?: () => number;
+  private readonly idFactory?: (args: { sequence: number; dequeId: CommandDequeId }) => string;
+
+  constructor(options?: CommandDequeOptions, state?: CommandDequeState<TCommand>, sequence = 0) {
+    this.state = state
+      ? cloneDequeState(state)
+      : {
+          id: options?.id ?? DEFAULT_DEQUE_ID,
+          lane: options?.lane,
+          priority: options?.priority ?? DEFAULT_PRIORITY,
+          items: [],
+        };
+    this.sequence = sequence;
+    this.now = options?.now;
+    this.idFactory = options?.idFactory;
+  }
+
+  get id(): CommandDequeId {
+    return this.state.id;
+  }
+
+  pushBack(command: TCommand, options?: PushCommandOptions): CommandDequeItem<TCommand> {
+    const item = this.createItem(command, options);
+    this.state.items.push(item);
+    return item;
+  }
+
+  pushFront(command: TCommand, options?: PushCommandOptions): CommandDequeItem<TCommand> {
+    const item = this.createItem(command, options);
+    this.state.items.unshift(item);
+    return item;
+  }
+
+  peekNext(): CommandDequeItem<TCommand> | undefined {
+    return this.peekFront();
+  }
+
+  popNext(): CommandDequeItem<TCommand> | undefined {
+    return this.popFront();
+  }
+
+  peekFront(): CommandDequeItem<TCommand> | undefined {
+    return this.state.items[0];
+  }
+
+  peekBack(): CommandDequeItem<TCommand> | undefined {
+    return this.state.items.at(-1);
+  }
+
+  popFront(): CommandDequeItem<TCommand> | undefined {
+    return this.state.items.shift();
+  }
+
+  popBack(): CommandDequeItem<TCommand> | undefined {
+    return this.state.items.pop();
+  }
+
+  listItems(): CommandDequeItem<TCommand>[] {
+    return this.state.items.map((item) => ({ ...item }));
+  }
+
+  getItem(id: string): CommandDequeItem<TCommand> | undefined {
+    const item = this.state.items.find((candidate) => candidate.id === id);
+    return item ? { ...item } : undefined;
+  }
+
+  nextAfter(itemId: string): CommandDequeItem<TCommand> | undefined {
+    const index = this.state.items.findIndex((item) => item.id === itemId);
+    const item = index >= 0 ? this.state.items[index + 1] : undefined;
+    return item ? { ...item } : undefined;
+  }
+
+  prevBefore(itemId: string): CommandDequeItem<TCommand> | undefined {
+    const index = this.state.items.findIndex((item) => item.id === itemId);
+    const item = index >= 0 ? this.state.items[index - 1] : undefined;
+    return item ? { ...item } : undefined;
+  }
+
+  drain(): CommandDequeItem<TCommand>[] {
+    const drained = this.listItems();
+    this.state.items.length = 0;
+    return drained;
+  }
+
+  drainWhere(predicate: (item: CommandDequeItem<TCommand>) => boolean): CommandDequeItem<TCommand>[] {
+    const drained: CommandDequeItem<TCommand>[] = [];
+    const kept: CommandDequeItem<TCommand>[] = [];
+    for (const item of this.state.items) {
+      if (predicate(item)) {
+        drained.push({ ...item });
+      } else {
+        kept.push(item);
+      }
+    }
+    this.state.items.length = 0;
+    this.state.items.push(...kept);
+    return drained;
+  }
+
+  hasPending(): boolean {
+    return this.state.items.length > 0;
+  }
+
+  snapshot(): CommandDequeState<TCommand> {
+    return cloneDequeState(this.state);
+  }
+
+  private createItem(command: TCommand, options?: PushCommandOptions): CommandDequeItem<TCommand> {
+    const nextSequence = this.sequence + 1;
+    this.sequence = nextSequence;
+    return {
+      id: options?.id ?? this.idFactory?.({ sequence: nextSequence, dequeId: this.state.id }) ?? `cmd-${nextSequence}`,
+      command,
+      insertedAt: options?.insertedAt ?? this.now?.() ?? Date.now(),
+      order: nextSequence,
+    };
+  }
+}
+
+class MultiCommandDequeGroup<TCommand, TRuntimeState> implements CommandDequeGroup<TCommand, TRuntimeState> {
+  private readonly state: CommandDequeGroupState<TCommand>;
+  private readonly selector: CommandDequeSelector<TCommand, TRuntimeState>;
+  private readonly now?: () => number;
+  private readonly idFactory?: (args: { sequence: number; dequeId: CommandDequeId }) => string;
+
+  constructor(
+    options?: CommandDequeGroupOptions<TCommand, TRuntimeState>,
+    state?: CommandDequeGroupState<TCommand>,
+  ) {
+    this.state = state
+      ? cloneGroupState(state)
+      : {
+          deques: {},
+          sequence: 0,
+        };
+    this.now = options?.now;
+    this.idFactory = options?.idFactory;
+    this.selector = options?.selector ?? defaultCommandDequeSelector;
+    for (const definition of options?.deques ?? []) {
+      this.ensureDequeState(definition);
+    }
+  }
+
+  getDeque(dequeId: CommandDequeId): CommandDeque<TCommand> {
+    if (!this.state.deques[dequeId]) {
+      this.state.deques[dequeId] = {
+        id: dequeId,
+        priority: DEFAULT_PRIORITY,
+        items: [],
+      };
+    }
+    return this.createDequeView(dequeId);
+  }
+
+  ensureDeque(definition: CommandDequeDefinition): CommandDeque<TCommand> {
+    const state = this.ensureDequeState(definition);
+    return this.createDequeView(state.id);
+  }
+
+  pushBack(command: TCommand, options: PushCommandToDequeOptions): CommandDequeItem<TCommand> {
+    return this.push(command, options, 'back');
+  }
+
+  pushFront(command: TCommand, options: PushCommandToDequeOptions): CommandDequeItem<TCommand> {
+    return this.push(command, options, 'front');
+  }
+
+  selectNext(
+    runtimeState: TRuntimeState,
+    selector: CommandDequeSelector<TCommand, TRuntimeState> = this.selector,
+  ): SelectedCommandDequeItem<TCommand> | undefined {
+    const selection = selector({ group: this.snapshot(), runtimeState });
+    if (!selection) {
+      return undefined;
+    }
+    return this.resolveSelection(selection);
+  }
+
+  popSelected(selection: CommandDequeSelection): SelectedCommandDequeItem<TCommand> | undefined {
+    const deque = this.state.deques[selection.dequeId];
+    if (!deque) {
+      return undefined;
+    }
+    const index = deque.items.findIndex((item) => item.id === selection.itemId);
+    if (index < 0) {
+      return undefined;
+    }
+    const [item] = deque.items.splice(index, 1);
+    return {
+      dequeId: deque.id,
+      itemId: item.id,
+      deque: cloneDequeState(deque),
+      item: { ...item },
+    };
+  }
+
+  takeNext(
+    runtimeState: TRuntimeState,
+    selector: CommandDequeSelector<TCommand, TRuntimeState> = this.selector,
+  ): SelectedCommandDequeItem<TCommand> | undefined {
+    const selected = this.selectNext(runtimeState, selector);
+    if (!selected) {
+      return undefined;
+    }
+    return this.popSelected(selected);
+  }
+
+  drainDeque(dequeId: CommandDequeId): CommandDequeItem<TCommand>[] {
+    const deque = this.state.deques[dequeId];
+    if (!deque) {
+      return [];
+    }
+    const drained = deque.items.map((item) => ({ ...item }));
+    deque.items.length = 0;
+    return drained;
+  }
+
+  drainWhereDeque(
+    dequeId: CommandDequeId,
+    predicate: (item: CommandDequeItem<TCommand>) => boolean,
+  ): CommandDequeItem<TCommand>[] {
+    const deque = this.state.deques[dequeId];
+    if (!deque) {
+      return [];
+    }
+    const drained: CommandDequeItem<TCommand>[] = [];
+    const kept: CommandDequeItem<TCommand>[] = [];
+    for (const item of deque.items) {
+      if (predicate(item)) {
+        drained.push({ ...item });
+      } else {
+        kept.push(item);
+      }
+    }
+    deque.items.length = 0;
+    deque.items.push(...kept);
+    return drained;
+  }
+
+  listDequeIds(): CommandDequeId[] {
+    return Object.keys(this.state.deques);
+  }
+
+  snapshot(): CommandDequeGroupState<TCommand> {
+    return cloneGroupState(this.state);
+  }
+
+  private push(
+    command: TCommand,
+    options: PushCommandToDequeOptions,
+    side: 'front' | 'back',
+  ): CommandDequeItem<TCommand> {
+    const deque = this.ensureDequeState({
+      id: options.dequeId,
+      priority: this.state.deques[options.dequeId]?.priority ?? DEFAULT_PRIORITY,
+    });
+    const nextSequence = this.state.sequence + 1;
+    this.state.sequence = nextSequence;
+    const item = {
+      id: options.id ?? this.idFactory?.({ sequence: nextSequence, dequeId: deque.id }) ?? `cmd-${nextSequence}`,
+      command,
+      insertedAt: options.insertedAt ?? this.now?.() ?? Date.now(),
+      order: nextSequence,
+    };
+    if (side === 'front') {
+      deque.items.unshift(item);
+    } else {
+      deque.items.push(item);
+    }
+    return { ...item };
+  }
+
+  private createDequeView(dequeId: CommandDequeId): CommandDeque<TCommand> {
+    return {
+      id: dequeId,
+      pushBack: (command, options) => this.pushBack(command, { ...options, dequeId }),
+      pushFront: (command, options) => this.pushFront(command, { ...options, dequeId }),
+      peekNext: () => this.peekDequeFront(dequeId),
+      popNext: () => this.popDequeFront(dequeId),
+      peekFront: () => this.peekDequeFront(dequeId),
+      peekBack: () => this.peekDequeBack(dequeId),
+      popFront: () => this.popDequeFront(dequeId),
+      popBack: () => this.popDequeBack(dequeId),
+      listItems: () => this.state.deques[dequeId]?.items.map((item) => ({ ...item })) ?? [],
+      getItem: (id) => {
+        const item = this.state.deques[dequeId]?.items.find((candidate) => candidate.id === id);
+        return item ? { ...item } : undefined;
+      },
+      nextAfter: (itemId) => this.neighbor(dequeId, itemId, 1),
+      prevBefore: (itemId) => this.neighbor(dequeId, itemId, -1),
+      drain: () => this.drainDeque(dequeId),
+      drainWhere: (predicate) => this.drainWhereDeque(dequeId, predicate),
+      hasPending: () => (this.state.deques[dequeId]?.items.length ?? 0) > 0,
+      snapshot: () => cloneDequeState(this.state.deques[dequeId] ?? this.ensureDequeState({ id: dequeId, priority: DEFAULT_PRIORITY })),
+    };
+  }
+
+  private peekDequeFront(dequeId: CommandDequeId): CommandDequeItem<TCommand> | undefined {
+    const item = this.state.deques[dequeId]?.items[0];
+    return item ? { ...item } : undefined;
+  }
+
+  private peekDequeBack(dequeId: CommandDequeId): CommandDequeItem<TCommand> | undefined {
+    const item = this.state.deques[dequeId]?.items.at(-1);
+    return item ? { ...item } : undefined;
+  }
+
+  private popDequeFront(dequeId: CommandDequeId): CommandDequeItem<TCommand> | undefined {
+    const item = this.state.deques[dequeId]?.items.shift();
+    return item ? { ...item } : undefined;
+  }
+
+  private popDequeBack(dequeId: CommandDequeId): CommandDequeItem<TCommand> | undefined {
+    const item = this.state.deques[dequeId]?.items.pop();
+    return item ? { ...item } : undefined;
+  }
+
+  private neighbor(dequeId: CommandDequeId, itemId: string, offset: 1 | -1): CommandDequeItem<TCommand> | undefined {
+    const items = this.state.deques[dequeId]?.items;
+    if (!items) {
+      return undefined;
+    }
+    const index = items.findIndex((item) => item.id === itemId);
+    const item = index >= 0 ? items[index + offset] : undefined;
+    return item ? { ...item } : undefined;
+  }
+
+  private resolveSelection(selection: CommandDequeSelection): SelectedCommandDequeItem<TCommand> | undefined {
+    const deque = this.state.deques[selection.dequeId];
+    const item = deque?.items.find((candidate) => candidate.id === selection.itemId);
+    if (!deque || !item) {
+      return undefined;
+    }
+    return {
+      dequeId: deque.id,
+      itemId: item.id,
+      deque: cloneDequeState(deque),
+      item: { ...item },
+    };
+  }
+
+  private ensureDequeState(definition: CommandDequeDefinition): CommandDequeState<TCommand> {
+    const existing = this.state.deques[definition.id];
+    if (existing) {
+      if (definition.lane !== undefined) {
+        existing.lane = definition.lane;
+      }
+      existing.priority = definition.priority;
+      return existing;
+    }
+    const created = {
+      id: definition.id,
+      lane: definition.lane,
+      priority: definition.priority,
+      items: [],
+    };
+    this.state.deques[definition.id] = created;
+    return created;
+  }
+}
+
+export function defaultCommandDequeSelector<TCommand, TRuntimeState>({
+  group,
+}: {
+  group: CommandDequeGroupState<TCommand>;
+  runtimeState: TRuntimeState;
+}): CommandDequeSelection | undefined {
+  const candidates = Object.values(group.deques)
+    .filter((deque) => deque.items.length > 0)
+    .map((deque) => ({
+      dequeId: deque.id,
+      priority: deque.priority,
+      item: deque.items[0],
+    }));
+
+  candidates.sort((a, b) => {
+    if (a.priority !== b.priority) {
+      return a.priority - b.priority;
+    }
+    return a.item.order - b.item.order;
+  });
+
+  const selected = candidates[0];
+  return selected ? { dequeId: selected.dequeId, itemId: selected.item.id } : undefined;
+}
+
+export function createCommandDeque<TCommand>(
+  options?: CommandDequeOptions,
+  state?: CommandDequeState<TCommand>,
+): CommandDeque<TCommand> {
+  return new SingleCommandDeque(options, state, maxOrder(state?.items ?? []));
+}
+
+export function createCommandDequeGroup<TCommand, TRuntimeState = unknown>(
+  options?: CommandDequeGroupOptions<TCommand, TRuntimeState>,
+  state?: CommandDequeGroupState<TCommand>,
+): CommandDequeGroup<TCommand, TRuntimeState> {
+  return new MultiCommandDequeGroup(options, state);
+}
+
+export interface CommandDequeMutationResult<TCommand> {
+  state: CommandDequeState<TCommand>;
+  item?: CommandDequeItem<TCommand>;
+  items?: CommandDequeItem<TCommand>[];
+}
+
+export function pushBackCommand<TCommand>(
+  state: CommandDequeState<TCommand>,
+  command: TCommand,
+  options?: CommandDequeOptions & PushCommandOptions,
+): CommandDequeMutationResult<TCommand> {
+  const deque = createCommandDeque(options, state);
+  const item = deque.pushBack(command, options);
+  return { state: deque.snapshot(), item };
+}
+
+export function pushFrontCommand<TCommand>(
+  state: CommandDequeState<TCommand>,
+  command: TCommand,
+  options?: CommandDequeOptions & PushCommandOptions,
+): CommandDequeMutationResult<TCommand> {
+  const deque = createCommandDeque(options, state);
+  const item = deque.pushFront(command, options);
+  return { state: deque.snapshot(), item };
+}
+
+export function popNextCommand<TCommand>(
+  state: CommandDequeState<TCommand>,
+): CommandDequeMutationResult<TCommand> {
+  const deque = createCommandDeque(undefined, state);
+  const item = deque.popNext();
+  return { state: deque.snapshot(), item };
+}
+
+export function popFrontCommand<TCommand>(
+  state: CommandDequeState<TCommand>,
+): CommandDequeMutationResult<TCommand> {
+  const deque = createCommandDeque(undefined, state);
+  const item = deque.popFront();
+  return { state: deque.snapshot(), item };
+}
+
+export function popBackCommand<TCommand>(
+  state: CommandDequeState<TCommand>,
+): CommandDequeMutationResult<TCommand> {
+  const deque = createCommandDeque(undefined, state);
+  const item = deque.popBack();
+  return { state: deque.snapshot(), item };
+}
+
+export function pushBackCommandToGroup<TCommand, TRuntimeState = unknown>(
+  state: CommandDequeGroupState<TCommand>,
+  command: TCommand,
+  options: CommandDequeGroupOptions<TCommand, TRuntimeState> & PushCommandToDequeOptions,
+): CommandDequeGroupMutationResult<TCommand> {
+  const group = createCommandDequeGroup(options, state);
+  const item = group.pushBack(command, options);
+  return { state: group.snapshot(), item };
+}
+
+export function pushFrontCommandToGroup<TCommand, TRuntimeState = unknown>(
+  state: CommandDequeGroupState<TCommand>,
+  command: TCommand,
+  options: CommandDequeGroupOptions<TCommand, TRuntimeState> & PushCommandToDequeOptions,
+): CommandDequeGroupMutationResult<TCommand> {
+  const group = createCommandDequeGroup(options, state);
+  const item = group.pushFront(command, options);
+  return { state: group.snapshot(), item };
+}
+
+export function popSelectedCommandFromGroup<TCommand, TRuntimeState = unknown>(
+  state: CommandDequeGroupState<TCommand>,
+  selection: CommandDequeSelection,
+  options?: CommandDequeGroupOptions<TCommand, TRuntimeState>,
+): CommandDequeGroupMutationResult<TCommand> {
+  const group = createCommandDequeGroup(options, state);
+  const selected = group.popSelected(selection);
+  return {
+    state: group.snapshot(),
+    item: selected?.item,
+    selection: selected,
+  };
+}
+
+export function takeNextCommandFromGroup<TCommand, TRuntimeState = unknown>(
+  state: CommandDequeGroupState<TCommand>,
+  runtimeState: TRuntimeState,
+  options?: CommandDequeGroupOptions<TCommand, TRuntimeState>,
+): CommandDequeGroupMutationResult<TCommand> {
+  const group = createCommandDequeGroup(options, state);
+  const selected = group.takeNext(runtimeState);
+  return {
+    state: group.snapshot(),
+    item: selected?.item,
+    selection: selected,
+  };
+}
+
+export function drainCommandDequeFromGroup<TCommand, TRuntimeState = unknown>(
+  state: CommandDequeGroupState<TCommand>,
+  dequeId: CommandDequeId,
+  options?: CommandDequeGroupOptions<TCommand, TRuntimeState>,
+): CommandDequeGroupMutationResult<TCommand> {
+  const group = createCommandDequeGroup(options, state);
+  const items = group.drainDeque(dequeId);
+  return { state: group.snapshot(), items };
+}
+
+export function drainWhereCommandDequeFromGroup<TCommand, TRuntimeState = unknown>(
+  state: CommandDequeGroupState<TCommand>,
+  dequeId: CommandDequeId,
+  predicate: (item: CommandDequeItem<TCommand>) => boolean,
+  options?: CommandDequeGroupOptions<TCommand, TRuntimeState>,
+): CommandDequeGroupMutationResult<TCommand> {
+  const group = createCommandDequeGroup(options, state);
+  const items = group.drainWhereDeque(dequeId, predicate);
+  return { state: group.snapshot(), items };
+}
+
+function cloneDequeState<TCommand>(state: CommandDequeState<TCommand>): CommandDequeState<TCommand> {
+  return {
+    id: state.id,
+    lane: state.lane,
+    priority: state.priority,
+    items: state.items.map((item) => ({ ...item })),
+  };
+}
+
+function cloneGroupState<TCommand>(state: CommandDequeGroupState<TCommand>): CommandDequeGroupState<TCommand> {
+  return {
+    deques: Object.fromEntries(
+      Object.entries(state.deques).map(([id, deque]) => [id, cloneDequeState(deque)]),
+    ),
+    sequence: state.sequence,
+  };
+}
+
+function maxOrder<TCommand>(items: CommandDequeItem<TCommand>[]): number {
+  return items.reduce((max, item) => Math.max(max, item.order), 0);
+}