import type {  OrchestrationProject,  OrchestrationReadModel,  OrchestrationThread,  ProjectId,  ThreadId,} from "@t3tools/contracts";import * as HashMap from "effect/HashMap";import * as HashSet from "effect/HashSet";import * as Option from "effect/Option"; /** * Server-internal representation of the orchestration read model. * * Unlike the wire {@link OrchestrationReadModel} (which uses arrays and is * produced by the DB-backed `ProjectionSnapshotQuery`), this model is only ever * touched by the single serial command-worker fiber in `OrchestrationEngine`. * It uses persistent `HashMap`s keyed by id so the projector and command * invariants get O(1)-ish lookups and single-key updates instead of O(N) * array scans and full-array copies on every event. * * The model is never serialized or sent over the wire, so its shape can evolve * independently of the contract. */export interface CommandReadModel {  readonly snapshotSequence: number;  readonly projects: HashMap.HashMap<ProjectId, OrchestrationProject>;  readonly threads: HashMap.HashMap<ThreadId, OrchestrationThread>;  /**   * Ids of threads that have been deleted. Deleted threads are evicted from   * `threads` (freeing their message/activity/checkpoint arrays), but their id   * is retained here so `requireThreadAbsent` still rejects re-creating a   * thread with a previously-used id — the "cannot be created twice" invariant   * the DB projection also upholds (its tombstone row is never removed).   */  readonly deletedThreadIds: HashSet.HashSet<ThreadId>;  readonly updatedAt: string;} export function createEmptyCommandReadModel(nowIso: string): CommandReadModel {  return {    snapshotSequence: 0,    projects: HashMap.empty<ProjectId, OrchestrationProject>(),    threads: HashMap.empty<ThreadId, OrchestrationThread>(),    deletedThreadIds: HashSet.empty<ThreadId>(),    updatedAt: nowIso,  };} /** * Whether a thread id has been used and deleted. Used by `requireThreadAbsent` * so an evicted (deleted) thread's id cannot be re-created. */export function isThreadDeleted(model: CommandReadModel, threadId: ThreadId): boolean {  return HashSet.has(model.deletedThreadIds, threadId);} /** * Seed a {@link CommandReadModel} from the array-based wire read model produced * by `ProjectionSnapshotQuery.getCommandReadModel()` at engine boot. * * Deleted threads are dropped so the in-memory model starts consistent with the * projector's eviction policy (deleted threads are removed, archived threads are * retained). The DB projection remains the source of truth for deleted rows. */export function fromWireReadModel(  model: OrchestrationReadModel,  options?: { readonly dropDeletedThreads?: boolean },): CommandReadModel {  const dropDeletedThreads = options?.dropDeletedThreads ?? true;  const threads = dropDeletedThreads    ? model.threads.filter((thread) => thread.deletedAt === null)    : model.threads;  // Retain the ids of deleted threads so the create-twice invariant survives  // a restart even though the (evicted) thread bodies are not loaded.  const deletedThreadIds = HashSet.fromIterable(    model.threads.filter((thread) => thread.deletedAt !== null).map((thread) => thread.id),  );  return {    snapshotSequence: model.snapshotSequence,    updatedAt: model.updatedAt,    projects: HashMap.fromIterable(model.projects.map((project) => [project.id, project] as const)),    threads: HashMap.fromIterable(threads.map((thread) => [thread.id, thread] as const)),    deletedThreadIds,  };} export function findThreadById(  model: CommandReadModel,  threadId: ThreadId,): OrchestrationThread | undefined {  return Option.getOrUndefined(HashMap.get(model.threads, threadId));} export function findProjectById(  model: CommandReadModel,  projectId: ProjectId,): OrchestrationProject | undefined {  return Option.getOrUndefined(HashMap.get(model.projects, projectId));} export function listThreadsByProjectId(  model: CommandReadModel,  projectId: ProjectId,): ReadonlyArray<OrchestrationThread> {  const result: OrchestrationThread[] = [];  for (const thread of HashMap.values(model.threads)) {    if (thread.projectId === projectId) {      result.push(thread);    }  }  // HashMap iteration order is not insertion order; sort by creation time (then  // id) so callers observe a stable, deterministic order — matching the prior  // array-backed behavior. Only used by the rare `project.delete` fan-out.  return result.toSorted(    (left, right) =>      left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id),  );}