Strata Sync

Models, adapters, and the sync protocol, with a full API reference.

npm install @stratasync/core @stratasync/client @stratasync/react @stratasync/mobx @stratasync/storage-idb @stratasync/transport-graphql

Three files. Or run npx skills add mblode/stratasync and let the skill scaffold them for you.

import { ClientModel, Model, Property } from "@stratasync/core";

@ClientModel("Todo", { loadStrategy: "instant" })
class Todo extends Model {
  @Property() declare title: string;
  @Property() declare completed: boolean;
}

import { createSyncClient } from "@stratasync/client";
import { createMobXReactivity } from "@stratasync/mobx";
import { createIndexedDbStorage } from "@stratasync/storage-idb";
import { createGraphQLTransport } from "@stratasync/transport-graphql";

const client = createSyncClient({
  storage: createIndexedDbStorage(),
  transport: createGraphQLTransport({
    endpoint: "/api/graphql",
    syncEndpoint: "/api/sync",
    wsEndpoint: "wss://api.example.com/sync/ws",
    auth: { getAccessToken: async () => "token" },
  }),
  reactivity: createMobXReactivity(),
});

import { observer } from "mobx-react-lite";
import { useQuery, useSyncClient } from "@stratasync/react";

const TodoList = observer(() => {
  const { data: todos } = useQuery("Todo", {
    where: (t) => !t.completed,
  });
  const { client } = useSyncClient();

  const addTodo = () =>
    client.create("Todo", { title: "New todo", completed: false });

  return (
    <ul>
      {todos.map((todo) => (
        <li key={todo.id}>{todo.title}</li>
      ))}
      <button onClick={addTodo}>Add</button>
    </ul>
  );
});

Linear's engineers described their sync engine in talks and posts, and the reverse-engineering notes wrote it down chapter by chapter. Strata Sync implements each chapter in TypeScript.

Beyond the published architecture, Strata Sync adds Yjs CRDT documents and presence for collaborative text (@stratasync/y-doc), and makes storage, transport and reactivity swappable adapters behind one interface each.

Strata Sync is a clean-room implementation of the published architecture. It contains no Linear code, and Linear is not affiliated with or endorsing this project.

• Instant reads: every query hits a local IndexedDB replica, so there are no spinners and no round-trips.
• Writes that survive offline: they queue in a durable outbox and drain in order when the connection returns, with idempotency keys so a retry never applies twice.
• Fine-grained reactivity: MobX observables mean only the components touching changed data re-render.
• Live collaboration and undo: Yjs CRDTs let several people edit one document, with history tracked per transaction.
• Swappable adapters: storage, transport, and reactivity are each a separate package.
• Your own backend: @stratasync/server registers routes on your Fastify app and stores the sync log in your Postgres through Drizzle. Redis is optional, for fanning deltas across processes.

Done Bear runs on Strata Sync: a web dashboard, a Tauri desktop shell, a SwiftUI iOS app, a CLI, a Raycast extension and a hosted MCP server, all reading and writing one Postgres over the same bootstrap, delta and mutate endpoints. (The iOS client is a Swift port of the protocol rather than these npm packages.)

Ten packages, so you install only the layers you use. Runnable examples live in examples/web and examples/api.

MIT

Crafted by Matthew Blode