import {  EnvironmentId,  type OrchestrationThread,  type OrchestrationShellSnapshot,  ThreadId,} from "@t3tools/contracts";import * as Context from "effect/Context";import * as Effect from "effect/Effect";import * as Option from "effect/Option";import * as Schema from "effect/Schema"; import type { ConnectionRegistration } from "../connection/catalog.ts";import {  type ConnectionStorageOperation,  ConnectionStorageOperationError,  type ConnectionTarget,  type ConnectionTransientError,} from "../connection/model.ts"; const isConnectionStorageOperationError = Schema.is(ConnectionStorageOperationError); export class ConnectionPersistenceError extends Schema.TaggedErrorClass<ConnectionPersistenceError>()(  "ConnectionPersistenceError",  {    operation: Schema.Literals([      "list-targets",      "register-connection",      "remove-connection",      "load-shell",      "save-shell",      "load-thread",      "save-thread",      "remove-thread",      "clear-environment",    ]),    stage: Schema.Literals([      "resolve",      "read",      "parse",      "decode",      "encode",      "migrate",      "write",      "remove",    ]),    resource: Schema.Literals([      "connection-catalog",      "shell-cache",      "legacy-shell-cache",      "thread-cache",    ]),    environmentId: Schema.optionalKey(EnvironmentId),    threadId: Schema.optionalKey(ThreadId),    cause: Schema.Defect(),  },) {  static fromStorageFailure(input: {    readonly operation: ConnectionPersistenceError["operation"];    readonly fallbackStage: ConnectionPersistenceError["stage"];    readonly resource: ConnectionPersistenceError["resource"];    readonly environmentId?: EnvironmentId;    readonly threadId?: ThreadId;    readonly cause: ConnectionTransientError;  }) {    const { cause, fallbackStage, ...attributes } = input;    const storageCause = cause.cause;    const stage = isConnectionStorageOperationError(storageCause)      ? ConnectionPersistenceError.storageOperationStage(storageCause.operation)      : fallbackStage;     return new ConnectionPersistenceError({      ...attributes,      stage,      cause,    });  }   private static storageOperationStage(    operation: ConnectionStorageOperation,  ): ConnectionPersistenceError["stage"] {    switch (operation) {      case "open":        return "resolve";      case "read":      case "load":        return "read";      case "decode":        return "decode";      case "encode":        return "encode";      case "migrate":        return "migrate";      case "write":      case "save":        return "write";      case "delete":      case "remove":        return "remove";    }  }   override get message(): string {    const environment =      this.environmentId === undefined ? "" : ` for environment ${this.environmentId}`;    const thread = this.threadId === undefined ? "" : ` and thread ${this.threadId}`;    return `Could not ${this.operation.replaceAll("-", " ")}: ${this.resource.replaceAll("-", " ")} ${this.stage} failed${environment}${thread}.`;  }} export class ConnectionTargetStore extends Context.Service<  ConnectionTargetStore,  {    readonly list: Effect.Effect<ReadonlyArray<ConnectionTarget>, ConnectionPersistenceError>;  }>()("@t3tools/client-runtime/platform/persistence/ConnectionTargetStore") {} export class ConnectionRegistrationStore extends Context.Service<  ConnectionRegistrationStore,  {    readonly register: (      registration: ConnectionRegistration,    ) => Effect.Effect<void, ConnectionPersistenceError>;    readonly remove: (target: ConnectionTarget) => Effect.Effect<void, ConnectionPersistenceError>;  }>()("@t3tools/client-runtime/platform/persistence/ConnectionRegistrationStore") {} export class EnvironmentCacheStore extends Context.Service<  EnvironmentCacheStore,  {    readonly loadShell: (      environmentId: EnvironmentId,    ) => Effect.Effect<Option.Option<OrchestrationShellSnapshot>, ConnectionPersistenceError>;    readonly saveShell: (      environmentId: EnvironmentId,      snapshot: OrchestrationShellSnapshot,    ) => Effect.Effect<void, ConnectionPersistenceError>;    readonly loadThread: (      environmentId: EnvironmentId,      threadId: ThreadId,    ) => Effect.Effect<Option.Option<OrchestrationThread>, ConnectionPersistenceError>;    readonly saveThread: (      environmentId: EnvironmentId,      thread: OrchestrationThread,    ) => Effect.Effect<void, ConnectionPersistenceError>;    readonly removeThread: (      environmentId: EnvironmentId,      threadId: ThreadId,    ) => Effect.Effect<void, ConnectionPersistenceError>;    readonly clear: (      environmentId: EnvironmentId,    ) => Effect.Effect<void, ConnectionPersistenceError>;  }>()("@t3tools/client-runtime/platform/persistence/EnvironmentCacheStore") {} export class EnvironmentOwnedDataCleanup extends Context.Reference<{  readonly clear: (environmentId: EnvironmentId) => Effect.Effect<void>;}>("@t3tools/client-runtime/platform/persistence/EnvironmentOwnedDataCleanup", {  defaultValue: () => ({    clear: () => Effect.void,  }),}) {}