Architecture Overview

┌─────────────────────────────────────────────────────────────┐
│                      Browser (Client)                        │
│                                                               │
│  ┌─────────────┐  ┌──────────────┐  ┌──────────────────┐   │
│  │   React UI  │  │ Service      │  │  Web Workers     │   │
│  │  (Vite SPA) │◄─┤ Worker       │◄─┤  (Build/Process) │   │
│  └──────┬──────┘  │ (Hono Router)│  └──────────────────┘   │
│         │         └──────┬───────┘                          │
│         ▼                ▼                                   │
│  ┌─────────────────────────────────────────────────────┐   │
│  │           Data Layer (Dexie/IndexedDB)              │   │
│  │  - Workspaces  - Builds  - Deployments              │   │
│  │  - Remote Auth - Destinations - History             │   │
│  └─────────────────────────────────────────────────────┘   │
│                          │                                   │
│         ┌────────────────┼────────────────┐                 │
│         ▼                ▼                ▼                 │
│  ┌──────────┐  ┌─────────────┐  ┌────────────┐             │
│  │ IndexedDB│  │    OPFS     │  │  LightningFS│             │
│  │  Disk    │  │ (Dir Mount) │  │  (Memory)   │             │
│  └──────────┘  └─────────────┘  └────────────┘             │
└─────────────────────────────────────────────────────────────┘
         │                │                 │
         └────────────────┴─────────────────┘
                          │
                  (Optional Remote)
                          │
              ┌───────────┴──────────┐
              ▼                      ▼
       ┌───────────┐         ┌─────────────┐
       │  GitHub   │         │  Netlify    │
       │   (Git)   │         │  Vercel     │
       └───────────┘         │  Cloudflare │
                             │  AWS S3     │
                             └─────────────┘

export class Workspace {
  imageCache: ImageCache;
  name: string;
  guid: string;
  private _disk: Disk;        // Virtual filesystem
  private _thumbs: Disk;       // Thumbnail storage
  private _repo: GitRepo;      // Git repository
  private _playbook: GitPlaybook;
  private _remoteAuths?: RemoteAuthDAO[];
  // ...
}

export abstract class Disk<TContext extends DiskContext = DiskContext> {
  remote: DiskEventsRemote;
  local: DiskEventsLocal;
  _fs: CommonFileSystem;      // Unified FS interface
  _fileTree: FileTree;         // In-memory tree structure
  abstract type: DiskType;
}

const app = new Hono<{ Variables: { workspaceName: string } }>();

// Routes:
app.post('/image/upload/:workspaceName/:imagePath', ...);  // Image uploads
app.get('/image/:workspaceName/*', ...);                    // Image serving
app.get('/md-render', ...);                                 // Markdown rendering
app.get('/search', ...);                                    // Content search
app.get('/download.zip', ...);                              // Workspace export

export class ClientIndexedDb extends Dexie {
  workspaces!: EntityTable<WorkspaceRecord, "guid">;
  remoteAuths!: EntityTable<RemoteAuthRecord, "guid">;
  destinations!: EntityTable<DestinationRecord, "guid">;
  settings!: EntityTable<SettingsRecord, "name">;
  disks!: EntityTable<DiskRecord, "guid">;
  builds!: EntityTable<BuildRecord, "guid">;
  deployments!: EntityTable<DeployRecord, "guid">;
  historyDocs!: EntityTable<HistoryDAO, "edit_id">;
}

import GIT from 'isomorphic-git';
import http from 'isomorphic-git/http/web';

export class GitRepo {
  // Core operations:
  async init();
  async commit(message: string, author: GitRepoAuthor);
  async push(remote: string, branch: string);
  async pull(remote: string, branch: string);
  async checkout(ref: string);
  async merge(branch: string): Promise<MergeResult>;
  // ...
}

// BuildRunner factory creates strategy-specific runners
export class BuildRunnerFactory {
  static create(strategy: BuildStrategy, workspace: Workspace) {
    switch (strategy) {
      case 'eleventy':
        return new EleventyBuildRunner(workspace);
      case 'freeform':
        return new BuildRunner(workspace);
    }
  }
}

UI Component
    ↓
Workspace.disk.readFile(path)
    ↓
Disk._fs.readFile(path)          // Virtual FS
    ↓
TranslateFs → NamespacedFs → MutexFs
    ↓
LightningFS / OPFS / IndexedDB   // Physical storage

User clicks "Build"
    ↓
BuildRunner.build()
    ↓
Web Worker (EleventyBuildRunner)  // Off main thread
    ↓
Template Engine Processing
    ↓
Generated files → memfs
    ↓
BuildRecord saved to IndexedDB
    ↓
[User clicks "Deploy"]
    ↓
DeployService (Netlify/Vercel/CF/S3)
    ↓
Zip creation → Upload
    ↓
DeployRecord saved to IndexedDB

User pastes/drops image
    ↓
Editor (MDX or CodeMirror)
    ↓
POST /image/upload/:workspace/:path (Service Worker)
    ↓
handleImageUpload()
    ↓
WebP conversion (if needed)
    ↓
Workspace.disk.writeFile()
    ↓
ImageCache.set()              // Thumbnail generation
    ↓
Markdown updated with image reference

// Example: Workspace disk setup
const fs = new HideFs(
  new MutexFs(
    new NamespacedFs(
      lightningFs,
      `/workspace-${guid}`
    )
  ),
  ['.git', '.opal']
);

// TypeEmitter for local events
class WorkspaceEventsLocal extends CreateSuperTypedEmitterClass<
  WorkspaceRemoteEventPayload
>() {}

// Channel for cross-context events (main ↔ service worker)
class WorkspaceEventsRemote extends Channel<
  WorkspaceRemoteEventPayload
> {}