# Is There Documentation for the Cloudflare Computer `dofs` Package? A Complete Guide

> Find complete documentation for the Cloudflare Computer dofs package. Explore the README, dedicated docs, and inline code examples within the Cloudflare Computer repository.

- Repository: [Cloudflare/computer](https://github.com/cloudflare/computer)
- Tags: api-reference
- Published: 2026-08-15

---

**Yes, the `@cloudflare/dofs` package is fully documented inside the Cloudflare Computer repository with a comprehensive README, dedicated docs, and extensive inline code examples.**

The **dofs** package (**D**urable-**O**bject **F**ile **S**ystem) provides a SQLite-backed virtual filesystem for Cloudflare Durable Objects. According to the Cloudflare Computer source code, all documentation lives alongside the implementation in `packages/dofs/`, ensuring every API change is immediately reflected in the docs.

## Where to Find `@cloudflare/dofs` Documentation

### Primary Documentation Files

The documentation is organized across four main locations:

- **[`packages/dofs/README.md`](https://github.com/cloudflare/computer/blob/main/packages/dofs/README.md)** — High-level overview, architecture diagram, and quick-start snippets
- **[`docs/01_vfs.md`](https://github.com/cloudflare/computer/blob/main/docs/01_vfs.md)** — Deep dive into the virtual filesystem layer and SQLite schema tables (`vfs_nodes`, `vfs_blobs`)
- **[`docs/02_sync_protocol.md`](https://github.com/cloudflare/computer/blob/main/docs/02_sync_protocol.md)** — Documentation for sync primitives used by the RPC layer
- **[`docs/04_filesystem_interface.md`](https://github.com/cloudflare/computer/blob/main/docs/04_filesystem_interface.md)** — Mapping of filesystem primitives to the public API

The README in [`packages/dofs/README.md`](https://github.com/cloudflare/computer/blob/main/packages/dofs/README.md) serves as the main entry point, describing the three logical layers that `dofs` exports: the **Database** wrapper, filesystem primitives, and the **SQLiteWorkspaceProvider** adapter.

## Core Architecture of `@cloudflare/dofs`

The package implements three distinct layers, each with dedicated documentation:

### 1. Database Layer

The **`Database`** class wraps a Durable Object's SQLite storage. It includes **`initializeSchema`**, a helper that creates the VFS tables required for file operations.

### 2. Filesystem Primitives Layer

Complete set of async filesystem operations implemented directly against the Database:

- `mkdir`, `rm`, `readdir`, `stat`, `chmod`
- `writeFile`, `readFile`
- `find`, `ls`, `grep`
- `symlink`, `readlink`
- `gc`, `watch`

Each primitive lives in its own source file under `src/fs/`. For example, `writeFile` is implemented in [`src/fs/writeFile.ts`](https://github.com/cloudflare/computer/blob/main/src/fs/writeFile.ts).

### 3. Provider Layer

**`SQLiteWorkspaceProvider`** adapts the primitives to a **Node-style filesystem** interface compatible with `@platformatic/vfs`. This includes fd tables, synchronous read/write, and watch capabilities. The `computerd` daemon uses this provider to expose a FUSE mount.

## How to Use `@cloudflare/dofs`: Code Examples

### Initialize a Durable Object Database

```typescript
import { Database, initializeSchema } from "@cloudflare/dofs";

export class WorkspaceDO extends DurableObject {
  private readonly db: Database;

  constructor(ctx: DurableObjectState, env: Env) {
    super(ctx, env);
    this.db = new Database(ctx.storage);
    // Initialise the VFS tables (vfs_nodes, vfs_blobs, …)
    initializeSchema(this.db, Date.now);
  }
}

```

This pattern appears in the README at lines 24-35 of [`packages/dofs/README.md`](https://github.com/cloudflare/computer/blob/main/packages/dofs/README.md).

### Write a File Using Primitives

```typescript
import { writeFile } from "@cloudflare/dofs/src/fs/writeFile";
import { Database } from "@cloudflare/dofs";

async function createHello(db: Database) {
  const path = "/hello.txt";
  const data = new TextEncoder().encode("Hello Cloudflare!");
  await writeFile(db, path, data);
}

```

The implementation in [`src/fs/writeFile.ts`](https://github.com/cloudflare/computer/blob/main/src/fs/writeFile.ts) handles blob storage, path normalization, and parent directory creation.

### Mount the Provider for Node-Style Access

```typescript
import { SQLiteWorkspaceProvider } from "@cloudflare/dofs";
import { Database } from "@cloudflare/dofs";

const db = new Database(/* Durable Object storage */);
const provider = new SQLiteWorkspaceProvider(db);

// Read a file synchronously
const contents = provider.readFileSync("/hello.txt", "utf8");
console.log(contents);

```

**`SQLiteWorkspaceProvider`** is the main export used by external consumers. The `computerd` daemon mounts this via FUSE to expose Durable Object storage as a local filesystem.

### Apply Sync Protocol Changes

```typescript
import { applyChanges } from "@cloudflare/dofs/src/sync/apply";

async function pushLocalChanges(db: Database) {
  // `changes` would normally be produced by the client side
  await applyChanges(db, changes);
}

```

Sync primitives like `applyChanges`, `fetchChanges`, and `pushObjects` live in `src/sync/` and power the bidirectional synchronization between local and remote state.

## Key Source Files for Deep Documentation

| Path | Description |
|------|-------------|
| [`packages/dofs/package.json`](https://github.com/cloudflare/computer/blob/main/packages/dofs/package.json) | NPM manifest with version, dependencies, export map |
| [`packages/dofs/src/index.ts`](https://github.com/cloudflare/computer/blob/main/packages/dofs/src/index.ts) | Public entry point; re-exports `Database`, `SQLiteWorkspaceProvider`, sync helpers |
| [`packages/dofs/src/schema/core.ts`](https://github.com/cloudflare/computer/blob/main/packages/dofs/src/schema/core.ts) | Core SQLite schema defining `vfs_nodes`, `vfs_blobs`, and related tables |
| [`packages/dofs/src/fs/writeFile.ts`](https://github.com/cloudflare/computer/blob/main/packages/dofs/src/fs/writeFile.ts) | `writeFile` primitive implementation |
| [`packages/dofs/src/fs/readFile.ts`](https://github.com/cloudflare/computer/blob/main/packages/dofs/src/fs/readFile.ts) | `writeFile` primitive implementation |
| [`packages/dofs/src/fs/stat.ts`](https://github.com/cloudflare/computer/blob/main/packages/dofs/src/fs/stat.ts) | `stat` metadata retrieval |
| [`packages/dofs/src/sync/apply.ts`](https://github.com/cloudflare/computer/blob/main/packages/dofs/src/sync/apply.ts) | Sync-protocol apply logic |
| [`packages/dofs/src/testing.ts`](https://github.com/cloudflare/computer/blob/main/packages/dofs/src/testing.ts) | `SQLiteTestStorage` — in-memory SQLite for unit tests |

Each source file includes JSDoc comments and is backed by corresponding [`.test.ts`](https://github.com/cloudflare/computer/blob/main/.test.ts) files that serve as executable documentation.

## Relationship to Other Packages

The **`dofs`** package sits at the center of the Cloudflare Computer stack:

- **`@cloudflare/computer-rpc`** consumes the sync primitives (`applyChanges`, `fetchChanges`) for remote procedure calls
- **`@platformatic/vfs`** defines the interface that `SQLiteWorkspaceProvider` implements
- **`computerd`** (the local daemon) mounts the provider via FUSE

Repository-wide documentation in [`docs/10_project_layout.md`](https://github.com/cloudflare/computer/blob/main/docs/10_project_layout.md) explains this placement and dependency graph.

## Summary

- **Yes, `@cloudflare/dofs` is thoroughly documented** via README, dedicated docs, and inline source comments
- The **README** ([`packages/dofs/README.md`](https://github.com/cloudflare/computer/blob/main/packages/dofs/README.md)) provides architectural overview and quick-start code
- **Filesystem primitives** are documented per-function in `src/fs/*.ts` with corresponding tests
- **Sync protocol primitives** are documented in `src/sync/*.ts` and [`docs/02_sync_protocol.md`](https://github.com/cloudflare/computer/blob/main/docs/02_sync_protocol.md)
- **SQLiteWorkspaceProvider** bridges `dofs` to Node-style filesystem consumers like `computerd`

## Frequently Asked Questions

### Where is the official `@cloudflare/dofs` documentation hosted?

The primary documentation lives in the Cloudflare Computer repository at [`packages/dofs/README.md`](https://github.com/cloudflare/computer/blob/main/packages/dofs/README.md). There is no separate documentation site — all reference material is maintained alongside the source code to ensure accuracy.

### What does `dofs` stand for?

`dofs` is short for **Durable-Object File System**. It provides SQLite-backed file storage and operations for Cloudflare Durable Objects, with sync capabilities for local-remote reconciliation.

### Can I use `@cloudflare/dofs` outside of Cloudflare Workers?

The `Database` class requires a Durable Object `Storage` interface. However, the package exports `SQLiteTestStorage` from [`src/testing.ts`](https://github.com/cloudflare/computer/blob/main/src/testing.ts) for local development and testing. Production use requires a Durable Object environment or compatible storage adapter.

### How does the sync protocol work in `@cloudflare/dofs`?

The sync protocol uses changeset-based reconciliation. Client and server exchange change records via `fetchChanges` and `applyChanges`. The `pushObjects` helper handles bulk object transfer. These primitives are consumed by `@cloudflare/computer-rpc` to implement real-time workspace synchronization.