Sync engine

bun add @pylonsync/sync

import { createSyncEngine } from "@pylonsync/sync";

const engine = createSyncEngine("https://your-app.com", {
  transport: "websocket",   // or "sse" or "poll"
  appName:   "default",
  persist:   true,          // enables IndexedDB persistence
});

await engine.start();

const todos = engine.store.list("Todo");
const todo  = engine.store.get("Todo", "t_123");

// Subscribe — fires on every store change (server push, optimistic mutation, identity flip)
const unsubscribe = engine.store.subscribe(() => {
  console.log("rows updated:", engine.store.list("Todo").length);
});
// later: unsubscribe();

// Insert — generates a stable client-side id and returns it. Pylon ids are
// client-generated, so this id is canonical: the server doesn't reassign it.
const id = await engine.insert("Todo", { title: "x", done: false });

// Update — applies locally, queues the change
await engine.update("Todo", id, { done: true });

// Delete — applies locally, queues the change
await engine.delete("Todo", id);

const { pending, failed } = engine.outbox();
// pending: writes made offline (or waiting for a sign-in), oldest first
// failed:  writes the server rejected, each with `error` and `errorCode`
for (const w of failed) {
  console.log(w.entity, w.rowId, w.kind, w.data, w.error, w.errorCode);
}

await engine.retryWrite(w.id, { door: "14B" });

engine.dismissWrite(w.id); // false when no failed write has that id

const query = engine.createInfiniteQuery("Post", { pageSize: 20 });
await query.loadMore();
console.log(query.data); // first 20 rows
await query.loadMore();
console.log(query.data); // first 40

query.subscribe(() => render());
query.reset(); // start over

import { getServerData } from "@pylonsync/sync";

// On the server (e.g. Next.js loader, Astro page):
const hydration = await getServerData("https://your-app.com", ["Todo", "User"], {
  token: req.cookies.pylon_token,
});

// On the client:
engine.hydrate(hydration);
await engine.start();

import { defaultStorage } from "@pylonsync/sync";

const storage = defaultStorage();  // localStorage on web, in-memory elsewhere
storage.set("pylon_token", "pylon_a1b2c3...");

import { createWriteThroughStorage, createSyncEngine } from "@pylonsync/sync";

const storage = createWriteThroughStorage(seed, async (key, value) => {
  if (value === null) await asyncBackend.remove(key);
  else                await asyncBackend.set(key, value);
});

const engine = createSyncEngine("https://your-app.com", { storage });

await engine.selectOrg("org_xyz");
// engine.resolvedSession() now reflects the new tenantId
// the local replica is reset because the visible set changed

const { selectOrg, clearOrg, signOut } = useSession(engine);

await selectOrg("org_xyz");   // switch active org
await clearOrg();             // drop active org (back to no-tenant state)
await signOut();              // revoke session server-side

createSyncEngine("https://your-app.com", {
  wsUrl: "wss://ws.your-app.com",  // when WS is on a separate hostname
});

engine.subscribeCrdt("Document", "doc_42");

const unregister = engine.onBinaryFrame((bytes) => {
  // route to your Loro decoder — see @pylonsync/loro
});

// later
engine.unsubscribeCrdt("Document", "doc_42");
unregister();

// Broadcast presence (typically cursor position, "typing" status)
engine.setPresence({ x: 100, y: 200, label: "Alice" });

// Publish to a topic
engine.publishTopic("chat:room_42", { from: "alice", text: "hi" });

// Drop everything — useful for sign-out flows
await engine.resetReplica();
// then re-pull or re-start

type SyncEngineConfig = {
  baseUrl: string;
  transport?: "websocket" | "sse" | "poll";  // default "websocket"
  wsUrl?: string;                             // override WS URL
  pollInterval?: number;                      // default 1000ms (poll mode)
  reconnectDelay?: number;                    // default 1000ms (backoff base)
  token?: string;                             // overrides storage
  persist?: boolean;                          // default true in browser
  appName?: string;                           // default "default"
  storage?: Storage;                          // sync key-value adapter
};

import { pylonFetch } from "@pylonsync/sync";

const config = { baseUrl: "https://your-app.com", token };

const todos = await pylonFetch<Todo[]>(config, "/api/entities/Todo");
await pylonFetch(config, "/api/entities/Todo", {
  method: "POST",
  body: JSON.stringify({ title: "x", done: false }),
});