Class Workspace

packages/computer/src/workspace.ts:205–961

) as GitClient;

export class Workspace {
  readonly #db: Database;
  readonly #fs: WorkspaceFilesystem;
  /**
   * Lazily-constructed dofs provider. Built on first `provider()`
   * call; cached so repeated callers share the same instance.
   */
  #provider: SQLiteWorkspaceProvider | undefined;
  readonly #backends: WorkspaceBackend[];
  readonly #backendsById: Map<string, WorkspaceBackend>;
  readonly #moduleBackendsById: Map<string, WorkspaceModuleBackend>;
  readonly #registeredBackendIds: Set<string>;
  readonly #callableBackendIds: Set<string>;
  readonly #defaultBackendId: string | undefined;
  readonly #defaultCommandBackendId: string | undefined;
  readonly #observer: WorkspaceObserver;
  readonly #now: () => number;
  readonly #waitUntil: ((promise: Promise<unknown>) => void) | undefined;
  readonly #retryScheduler: SyncRetryScheduler | undefined;
  readonly #retryInitialDelayMs: number;
  readonly #retryMaxDelayMs: number;
  readonly #retryMaxAttempts: number;
  readonly #sessionId: string;
  readonly #gitFactory: WorkspaceGitFactory | undefined;
  readonly #defaultGitIdentity: GitIdentity | undefined;
  readonly #useThink: boolean;
  readonly #assets: AssetsClient | undefined;
  readonly #artifacts: ArtifactClient;
  // Lazily-constructed git client, cached so the dynamic
  // imports of isomorphic-git / diff land once per Workspace.
  #git: GitClient | undefined;
  readonly #mounts: Map<string, Mount>;
  readonly #mountIndex: MountIndex;
  // Per-backend handle cache. Filled lazily on first use of each
  // backend; a closed transport drops just that backend's entry,
  // leaving the others warm.
  readonly #handles = new Map<string, BackendHandle>();
  // In-flight connect promises keyed by backend id, so concurrent
  // callers for the same backend share one connect pass.
  readonly #connecting = new Map<string, Promise<BackendHandle>>();
  // Per-backend WorkspaceShell facades. Constructed alongside each
  // handle; reused for the life of the handle.
  readonly #shells = new Map<string, WorkspaceShell>();
  readonly #moduleHandles = new Map<string, WorkspaceModuleBackendHandle>();
  readonly #connectingModuleHandles = new Map<string, Promise<WorkspaceModuleBackendHandle>>();
  #connectionGeneration = 0;
  #runtime: WorkspaceRuntime | undefined;
  #readyPromise: Promise<void> | undefined;
  // Per-backend FIFOs that serialize mutating entry points (push,
  // pull, and the shell exec bracket which goes through them) for
  // that backend. A push to backend A does not block exec on
  // backend B. Reads bypass the queue entirely — they hit the
  // local store directly through Workspace.fs. Each value is a
  // single tail-promise; each caller chains its work onto the tail
  // and updates it. See docs/02 "Concurrent mutators".
  readonly #mutationTails = new Map<string, Promise<unknown>>();

  declare readonly readFile?: ThinkWorkspaceCompatibility["readFile"];