@super-line/store-sync-pglite 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mert
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.cjs

@@ -0,0 +1,282 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  syncPgliteStoreServer: () => syncPgliteStoreServer
+});
+module.exports = __toCommonJS(index_exports);
+var import_pglite = require("@electric-sql/pglite");
+var import_live = require("@electric-sql/pglite/live");
+var import_pglite_sync = require("@electric-sql/pglite-sync");
+var import_postgres = __toESM(require("postgres"), 1);
+var import_core = require("@super-line/core");
+var import_store = require("@super-store/store");
+var IDENT = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var SERVER_ORIGIN = "server";
+var BASELINE_ORIGIN = "sl-baseline";
+var b64 = (u) => {
+  let s = "";
+  for (const byte of u) s += String.fromCharCode(byte);
+  return btoa(s);
+};
+var fromB64 = (s) => {
+  const bin = atob(s);
+  const u = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) u[i] = bin.charCodeAt(i);
+  return u;
+};
+async function syncPgliteStoreServer(opts) {
+  const meta = opts.table ?? "resources";
+  if (!IDENT.test(meta)) throw new Error(`Invalid table name: ${meta}`);
+  const ups = `${meta}_updates`;
+  if (ups.length > 63) throw new Error(`Table name too long: "${meta}" \u2014 "${ups}" exceeds Postgres' 63-char limit`);
+  const ddlMeta = `CREATE TABLE IF NOT EXISTS "${meta}" (id text PRIMARY KEY, access jsonb NOT NULL, origin text, data jsonb)`;
+  const ddlUps = `CREATE TABLE IF NOT EXISTS "${ups}" (seq bigserial PRIMARY KEY, res_id text NOT NULL, update text NOT NULL, origin text)`;
+  const sql = (0, import_postgres.default)(opts.pgUrl, { prepare: false, onnotice: () => {
+  } });
+  const RACE_OK = /* @__PURE__ */ new Set(["42P07", "42710", "23505"]);
+  for (const ddl of [ddlMeta, ddlUps]) {
+    try {
+      await sql.unsafe(ddl);
+    } catch (err) {
+      if (!RACE_OK.has(err.code ?? "")) throw err;
+    }
+  }
+  const asJson = (v) => sql.json(v);
+  const ownsDb = !opts.db;
+  const db = opts.db ?? await import_pglite.PGlite.create({ extensions: { live: import_live.live, sync: (0, import_pglite_sync.electricSync)() } });
+  await db.exec(ddlMeta);
+  await db.exec(ddlUps);
+  const changeCbs = /* @__PURE__ */ new Set();
+  const deleteCbs = /* @__PURE__ */ new Set();
+  const onError = opts.onError ?? ((err, ctx) => console.error(`[store-sync-pglite] ${ctx.op} failed for ${ctx.id} (write not replicated):`, err));
+  const docs = /* @__PURE__ */ new Map();
+  let currentOrigin = SERVER_ORIGIN;
+  const getDoc = (id) => {
+    const existing = docs.get(id);
+    if (existing) return existing;
+    const d = new import_store.StoreValue({}, opts.resolveOptions?.(id));
+    d.encodeState();
+    d.onUpdate((update, m) => {
+      if (!m.local) return;
+      const origin = currentOrigin;
+      void sql`INSERT INTO ${sql(ups)} (res_id, update, origin) VALUES (${id}, ${b64(update)}, ${origin})`.catch((err) => onError(err, { op: "append", id }));
+    });
+    docs.set(id, d);
+    return d;
+  };
+  const withOrigin = (origin, fn) => {
+    currentOrigin = origin;
+    try {
+      fn();
+    } finally {
+      currentOrigin = SERVER_ORIGIN;
+    }
+  };
+  const foldFromCentral = async (id) => {
+    const d = getDoc(id);
+    const rows = await sql`SELECT update FROM ${sql(ups)} WHERE res_id = ${id} ORDER BY seq`;
+    for (const r of rows) d.applyUpdate(fromB64(r.update));
+    return d;
+  };
+  const compactCfg = opts.compact === false ? null : { everyN: opts.compact?.everyNUpdates ?? 200, debounceMs: opts.compact?.debounceMs ?? 2e3 };
+  const appendsSince = /* @__PURE__ */ new Map();
+  const compacting = /* @__PURE__ */ new Set();
+  const compactTimers = /* @__PURE__ */ new Map();
+  const compact = async (id) => {
+    await sql.begin(async (tx) => {
+      const rows = await tx`SELECT seq, update FROM ${tx(ups)} WHERE res_id = ${id} ORDER BY seq`;
+      if (rows.length < 2) return;
+      const maxSeq = rows[rows.length - 1]?.seq;
+      const doc = new import_store.StoreValue({}, opts.resolveOptions?.(id));
+      for (const r of rows) doc.applyUpdate(fromB64(r.update));
+      const baseline = b64(doc.encodeState());
+      const snapshot = doc.getSnapshot();
+      doc.dispose();
+      await tx`INSERT INTO ${tx(ups)} (res_id, update, origin) VALUES (${id}, ${baseline}, ${BASELINE_ORIGIN})`;
+      await tx`DELETE FROM ${tx(ups)} WHERE res_id = ${id} AND seq <= ${maxSeq}`;
+      await tx`UPDATE ${tx(meta)} SET data = ${asJson(snapshot)} WHERE id = ${id}`;
+    });
+  };
+  const scheduleCompact = (id) => {
+    if (!compactCfg) return;
+    const n = (appendsSince.get(id) ?? 0) + 1;
+    appendsSince.set(id, n);
+    const fire = () => {
+      compactTimers.delete(id);
+      appendsSince.set(id, 0);
+      if (compacting.has(id)) return;
+      compacting.add(id);
+      void compact(id).catch((err) => onError(err, { op: "append", id })).finally(() => compacting.delete(id));
+    };
+    const existing = compactTimers.get(id);
+    if (existing) clearTimeout(existing);
+    if (n >= compactCfg.everyN) {
+      fire();
+      return;
+    }
+    const t = setTimeout(fire, compactCfg.debounceMs);
+    t.unref?.();
+    compactTimers.set(id, t);
+  };
+  const upsSub = await db.live.changes(`SELECT seq, res_id, update, origin FROM "${ups}"`, [], "seq", (changes) => {
+    for (const ch of changes) {
+      if (ch.__op__ !== "INSERT" && ch.__op__ !== "UPDATE") continue;
+      try {
+        getDoc(ch.res_id).applyUpdate(fromB64(ch.update));
+        if (ch.origin === BASELINE_ORIGIN) continue;
+        const change = { id: ch.res_id, update: ch.update, origin: ch.origin ?? "" };
+        for (const cb of changeCbs) cb(change);
+        scheduleCompact(ch.res_id);
+      } catch (err) {
+        onError(err, { op: "append", id: ch.res_id });
+      }
+    }
+  });
+  const metaSub = await db.live.changes(`SELECT id FROM "${meta}"`, [], "id", (changes) => {
+    for (const ch of changes) {
+      if (ch.__op__ !== "DELETE") continue;
+      docs.get(ch.id)?.dispose();
+      docs.delete(ch.id);
+      for (const cb of deleteCbs) cb(ch.id);
+    }
+  });
+  const shapes = opts.electricUrl && db.sync ? await Promise.all(
+    [meta, ups].map(
+      (t) => db.sync.syncShapeToTable({
+        shape: { url: opts.electricUrl, params: { table: t } },
+        table: t,
+        primaryKey: t === meta ? ["id"] : ["seq"],
+        shapeKey: null
+      })
+    )
+  ) : [];
+  return {
+    clustering: "self",
+    model: "crdt",
+    async read(id) {
+      const rows = await sql`SELECT access::text AS access FROM ${sql(meta)} WHERE id = ${id}`;
+      const row = rows[0];
+      if (!row) return void 0;
+      const doc = docs.get(id) ?? await foldFromCentral(id);
+      return { id, data: b64(doc.encodeState()), accessRules: JSON.parse(row.access) };
+    },
+    async create(id, data, accessRules) {
+      const seedDoc = new import_store.StoreValue(data ?? {}, opts.resolveOptions?.(id));
+      const seed = b64(seedDoc.encodeState());
+      const snapshot = seedDoc.getSnapshot();
+      seedDoc.dispose();
+      await sql.begin(async (tx) => {
+        const res = await tx`INSERT INTO ${tx(meta)} (id, access, origin, data)
+          VALUES (${id}, ${asJson(accessRules)}, ${null}, ${asJson(snapshot)})
+          ON CONFLICT (id) DO NOTHING`;
+        if (res.count === 0) throw new import_core.SuperLineError("CONFLICT", `Resource already exists: ${id}`);
+        await tx`INSERT INTO ${tx(ups)} (res_id, update, origin) VALUES (${id}, ${seed}, ${null})`;
+      });
+      getDoc(id).applyUpdate(fromB64(seed));
+    },
+    async apply(change) {
+      if (typeof change.update !== "string") {
+        const rows = await sql`SELECT 1 FROM ${sql(meta)} WHERE id = ${change.id}`;
+        if (rows.count === 0) throw new import_core.SuperLineError("NOT_FOUND", `No resource: ${change.id}`);
+        withOrigin(change.origin, () => void getDoc(change.id).update(change.update));
+        return;
+      }
+      const res = await sql`INSERT INTO ${sql(ups)} (res_id, update, origin)
+        SELECT ${change.id}, ${change.update}, ${change.origin}
+        WHERE EXISTS (SELECT 1 FROM ${sql(meta)} WHERE id = ${change.id})`;
+      if (res.count === 0) throw new import_core.SuperLineError("NOT_FOUND", `No resource: ${change.id}`);
+    },
+    open(id, openOpts) {
+      const doc = getDoc(id);
+      const origin = openOpts?.origin ?? SERVER_ORIGIN;
+      const subs = /* @__PURE__ */ new Set();
+      return {
+        getSnapshot: () => doc.getSnapshot(),
+        subscribe: (cb) => {
+          const off = doc.subscribe(cb);
+          subs.add(off);
+          return () => {
+            off();
+            subs.delete(off);
+          };
+        },
+        set: (value) => withOrigin(origin, () => void doc.set(value)),
+        update: (partial) => withOrigin(origin, () => void doc.update(partial)),
+        // Surgical key removal: read live state, drop the path, set() (diff-and-patch) — the only delete-capable
+        // surface (update MERGES, so it can never remove a key). Atomic in-process.
+        delete: (path) => withOrigin(origin, () => void doc.set((0, import_core.removeAtPath)(doc.getSnapshot(), path))),
+        close: () => {
+          for (const off of subs) off();
+          subs.clear();
+        }
+      };
+    },
+    async setAccess(id, accessRules) {
+      const res = await sql`UPDATE ${sql(meta)} SET access = ${asJson(accessRules)} WHERE id = ${id}`;
+      if (res.count === 0) throw new import_core.SuperLineError("NOT_FOUND", `No resource: ${id}`);
+    },
+    async delete(id) {
+      await sql.begin(async (tx) => {
+        await tx`DELETE FROM ${tx(meta)} WHERE id = ${id}`;
+        await tx`DELETE FROM ${tx(ups)} WHERE res_id = ${id}`;
+      });
+    },
+    async list() {
+      const rows = await sql`SELECT id FROM ${sql(meta)}`;
+      return rows.map((r) => r.id);
+    },
+    onChange(cb) {
+      changeCbs.add(cb);
+      return () => changeCbs.delete(cb);
+    },
+    onDelete(cb) {
+      deleteCbs.add(cb);
+      return () => deleteCbs.delete(cb);
+    },
+    async close() {
+      for (const t of compactTimers.values()) clearTimeout(t);
+      compactTimers.clear();
+      try {
+        await upsSub.unsubscribe();
+        await metaSub.unsubscribe();
+        for (const s of shapes) s.unsubscribe();
+        if (ownsDb) await db.close();
+      } finally {
+        await sql.end();
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  syncPgliteStoreServer
+});

package/dist/index.d.cts

@@ -0,0 +1,51 @@
+import { PGliteWithLive } from '@electric-sql/pglite/live';
+import { ServerStore } from '@super-line/core';
+
+/** Per-resource super-store config (mode + opaque paths). Supply the SAME resolver to the client's
+ * `syncStoreClient` so both halves build each resource's Yjs doc identically (no mode drift). */
+interface DocOptions {
+    mode?: 'shallow' | 'document';
+    opaque?: string[];
+}
+/** Options for {@link syncPgliteStoreServer}. */
+interface SyncPgliteStoreOptions {
+    /** Connection string for the central Postgres — source of truth for the op-log + strong ACL/existence. */
+    pgUrl: string;
+    /** Electric shape endpoint (e.g. `http://localhost:3000/v1/shape`). Omit to disable sync (tests feed the replica). */
+    electricUrl?: string;
+    /** Table prefix: creates `<table>` (existence + ACL) and `<table>_updates` (the Yjs op-log). Default `resources`. */
+    table?: string;
+    /** Advanced/testing: supply the local PGlite replica (needs the `live` extension; add `electricSync` for real sync). */
+    db?: PGliteWithLive;
+    /** Per-resource doc mode — must match the client's `syncStoreClient({ resolveOptions })`. */
+    resolveOptions?: (id: string) => DocOptions | undefined;
+    /**
+     * Op-log compaction: fold the log → materialize `<table>.data` (SQL-queryable board) + a baseline row →
+     * trim superseded rows. Bounds op-log growth and keeps a (debounced, eventually-consistent) snapshot in
+     * `<table>.data`. `false` disables it (pure append-only log). Single-writer per resource across the cluster.
+     */
+    compact?: false | {
+        everyNUpdates?: number;
+        debounceMs?: number;
+    };
+    /**
+     * Called when a background op-log append (a server co-write through `open()`/`apply`-object) fails to persist.
+     * Those writes are synchronous (`ServerReplica` returns void), so the INSERT can't reject to the caller — this
+     * is the only place the failure is observable. Defaults to `console.error`.
+     */
+    onError?: (err: unknown, ctx: {
+        op: 'append';
+        id: string;
+    }) => void;
+}
+/**
+ * The self-clustering, **CRDT** server half (`clustering:'self'`, `model:'crdt'`). Writes append a Yjs delta
+ * to a central `<table>_updates` op-log; Electric streams the op-log to each node's in-memory PGlite replica,
+ * whose `live.changes` folds every delta into a per-resource super-store doc and surfaces it through
+ * {@link ServerStore.onChange} — which core fans to LOCAL subscribers only. Strong ACL/existence reads hit
+ * central Postgres. `open()` returns a reactive {@link ServerReplica} over the in-memory doc (the agent
+ * co-writer). Pair with `syncStoreClient()` on the client.
+ */
+declare function syncPgliteStoreServer(opts: SyncPgliteStoreOptions): Promise<ServerStore>;
+
+export { type DocOptions, type SyncPgliteStoreOptions, syncPgliteStoreServer };

package/dist/index.d.ts

@@ -0,0 +1,51 @@
+import { PGliteWithLive } from '@electric-sql/pglite/live';
+import { ServerStore } from '@super-line/core';
+
+/** Per-resource super-store config (mode + opaque paths). Supply the SAME resolver to the client's
+ * `syncStoreClient` so both halves build each resource's Yjs doc identically (no mode drift). */
+interface DocOptions {
+    mode?: 'shallow' | 'document';
+    opaque?: string[];
+}
+/** Options for {@link syncPgliteStoreServer}. */
+interface SyncPgliteStoreOptions {
+    /** Connection string for the central Postgres — source of truth for the op-log + strong ACL/existence. */
+    pgUrl: string;
+    /** Electric shape endpoint (e.g. `http://localhost:3000/v1/shape`). Omit to disable sync (tests feed the replica). */
+    electricUrl?: string;
+    /** Table prefix: creates `<table>` (existence + ACL) and `<table>_updates` (the Yjs op-log). Default `resources`. */
+    table?: string;
+    /** Advanced/testing: supply the local PGlite replica (needs the `live` extension; add `electricSync` for real sync). */
+    db?: PGliteWithLive;
+    /** Per-resource doc mode — must match the client's `syncStoreClient({ resolveOptions })`. */
+    resolveOptions?: (id: string) => DocOptions | undefined;
+    /**
+     * Op-log compaction: fold the log → materialize `<table>.data` (SQL-queryable board) + a baseline row →
+     * trim superseded rows. Bounds op-log growth and keeps a (debounced, eventually-consistent) snapshot in
+     * `<table>.data`. `false` disables it (pure append-only log). Single-writer per resource across the cluster.
+     */
+    compact?: false | {
+        everyNUpdates?: number;
+        debounceMs?: number;
+    };
+    /**
+     * Called when a background op-log append (a server co-write through `open()`/`apply`-object) fails to persist.
+     * Those writes are synchronous (`ServerReplica` returns void), so the INSERT can't reject to the caller — this
+     * is the only place the failure is observable. Defaults to `console.error`.
+     */
+    onError?: (err: unknown, ctx: {
+        op: 'append';
+        id: string;
+    }) => void;
+}
+/**
+ * The self-clustering, **CRDT** server half (`clustering:'self'`, `model:'crdt'`). Writes append a Yjs delta
+ * to a central `<table>_updates` op-log; Electric streams the op-log to each node's in-memory PGlite replica,
+ * whose `live.changes` folds every delta into a per-resource super-store doc and surfaces it through
+ * {@link ServerStore.onChange} — which core fans to LOCAL subscribers only. Strong ACL/existence reads hit
+ * central Postgres. `open()` returns a reactive {@link ServerReplica} over the in-memory doc (the agent
+ * co-writer). Pair with `syncStoreClient()` on the client.
+ */
+declare function syncPgliteStoreServer(opts: SyncPgliteStoreOptions): Promise<ServerStore>;
+
+export { type DocOptions, type SyncPgliteStoreOptions, syncPgliteStoreServer };

package/dist/index.js

@@ -0,0 +1,247 @@
+// src/index.ts
+import { PGlite } from "@electric-sql/pglite";
+import { live } from "@electric-sql/pglite/live";
+import { electricSync } from "@electric-sql/pglite-sync";
+import postgres from "postgres";
+import { SuperLineError, removeAtPath } from "@super-line/core";
+import { StoreValue } from "@super-store/store";
+var IDENT = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var SERVER_ORIGIN = "server";
+var BASELINE_ORIGIN = "sl-baseline";
+var b64 = (u) => {
+  let s = "";
+  for (const byte of u) s += String.fromCharCode(byte);
+  return btoa(s);
+};
+var fromB64 = (s) => {
+  const bin = atob(s);
+  const u = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) u[i] = bin.charCodeAt(i);
+  return u;
+};
+async function syncPgliteStoreServer(opts) {
+  const meta = opts.table ?? "resources";
+  if (!IDENT.test(meta)) throw new Error(`Invalid table name: ${meta}`);
+  const ups = `${meta}_updates`;
+  if (ups.length > 63) throw new Error(`Table name too long: "${meta}" \u2014 "${ups}" exceeds Postgres' 63-char limit`);
+  const ddlMeta = `CREATE TABLE IF NOT EXISTS "${meta}" (id text PRIMARY KEY, access jsonb NOT NULL, origin text, data jsonb)`;
+  const ddlUps = `CREATE TABLE IF NOT EXISTS "${ups}" (seq bigserial PRIMARY KEY, res_id text NOT NULL, update text NOT NULL, origin text)`;
+  const sql = postgres(opts.pgUrl, { prepare: false, onnotice: () => {
+  } });
+  const RACE_OK = /* @__PURE__ */ new Set(["42P07", "42710", "23505"]);
+  for (const ddl of [ddlMeta, ddlUps]) {
+    try {
+      await sql.unsafe(ddl);
+    } catch (err) {
+      if (!RACE_OK.has(err.code ?? "")) throw err;
+    }
+  }
+  const asJson = (v) => sql.json(v);
+  const ownsDb = !opts.db;
+  const db = opts.db ?? await PGlite.create({ extensions: { live, sync: electricSync() } });
+  await db.exec(ddlMeta);
+  await db.exec(ddlUps);
+  const changeCbs = /* @__PURE__ */ new Set();
+  const deleteCbs = /* @__PURE__ */ new Set();
+  const onError = opts.onError ?? ((err, ctx) => console.error(`[store-sync-pglite] ${ctx.op} failed for ${ctx.id} (write not replicated):`, err));
+  const docs = /* @__PURE__ */ new Map();
+  let currentOrigin = SERVER_ORIGIN;
+  const getDoc = (id) => {
+    const existing = docs.get(id);
+    if (existing) return existing;
+    const d = new StoreValue({}, opts.resolveOptions?.(id));
+    d.encodeState();
+    d.onUpdate((update, m) => {
+      if (!m.local) return;
+      const origin = currentOrigin;
+      void sql`INSERT INTO ${sql(ups)} (res_id, update, origin) VALUES (${id}, ${b64(update)}, ${origin})`.catch((err) => onError(err, { op: "append", id }));
+    });
+    docs.set(id, d);
+    return d;
+  };
+  const withOrigin = (origin, fn) => {
+    currentOrigin = origin;
+    try {
+      fn();
+    } finally {
+      currentOrigin = SERVER_ORIGIN;
+    }
+  };
+  const foldFromCentral = async (id) => {
+    const d = getDoc(id);
+    const rows = await sql`SELECT update FROM ${sql(ups)} WHERE res_id = ${id} ORDER BY seq`;
+    for (const r of rows) d.applyUpdate(fromB64(r.update));
+    return d;
+  };
+  const compactCfg = opts.compact === false ? null : { everyN: opts.compact?.everyNUpdates ?? 200, debounceMs: opts.compact?.debounceMs ?? 2e3 };
+  const appendsSince = /* @__PURE__ */ new Map();
+  const compacting = /* @__PURE__ */ new Set();
+  const compactTimers = /* @__PURE__ */ new Map();
+  const compact = async (id) => {
+    await sql.begin(async (tx) => {
+      const rows = await tx`SELECT seq, update FROM ${tx(ups)} WHERE res_id = ${id} ORDER BY seq`;
+      if (rows.length < 2) return;
+      const maxSeq = rows[rows.length - 1]?.seq;
+      const doc = new StoreValue({}, opts.resolveOptions?.(id));
+      for (const r of rows) doc.applyUpdate(fromB64(r.update));
+      const baseline = b64(doc.encodeState());
+      const snapshot = doc.getSnapshot();
+      doc.dispose();
+      await tx`INSERT INTO ${tx(ups)} (res_id, update, origin) VALUES (${id}, ${baseline}, ${BASELINE_ORIGIN})`;
+      await tx`DELETE FROM ${tx(ups)} WHERE res_id = ${id} AND seq <= ${maxSeq}`;
+      await tx`UPDATE ${tx(meta)} SET data = ${asJson(snapshot)} WHERE id = ${id}`;
+    });
+  };
+  const scheduleCompact = (id) => {
+    if (!compactCfg) return;
+    const n = (appendsSince.get(id) ?? 0) + 1;
+    appendsSince.set(id, n);
+    const fire = () => {
+      compactTimers.delete(id);
+      appendsSince.set(id, 0);
+      if (compacting.has(id)) return;
+      compacting.add(id);
+      void compact(id).catch((err) => onError(err, { op: "append", id })).finally(() => compacting.delete(id));
+    };
+    const existing = compactTimers.get(id);
+    if (existing) clearTimeout(existing);
+    if (n >= compactCfg.everyN) {
+      fire();
+      return;
+    }
+    const t = setTimeout(fire, compactCfg.debounceMs);
+    t.unref?.();
+    compactTimers.set(id, t);
+  };
+  const upsSub = await db.live.changes(`SELECT seq, res_id, update, origin FROM "${ups}"`, [], "seq", (changes) => {
+    for (const ch of changes) {
+      if (ch.__op__ !== "INSERT" && ch.__op__ !== "UPDATE") continue;
+      try {
+        getDoc(ch.res_id).applyUpdate(fromB64(ch.update));
+        if (ch.origin === BASELINE_ORIGIN) continue;
+        const change = { id: ch.res_id, update: ch.update, origin: ch.origin ?? "" };
+        for (const cb of changeCbs) cb(change);
+        scheduleCompact(ch.res_id);
+      } catch (err) {
+        onError(err, { op: "append", id: ch.res_id });
+      }
+    }
+  });
+  const metaSub = await db.live.changes(`SELECT id FROM "${meta}"`, [], "id", (changes) => {
+    for (const ch of changes) {
+      if (ch.__op__ !== "DELETE") continue;
+      docs.get(ch.id)?.dispose();
+      docs.delete(ch.id);
+      for (const cb of deleteCbs) cb(ch.id);
+    }
+  });
+  const shapes = opts.electricUrl && db.sync ? await Promise.all(
+    [meta, ups].map(
+      (t) => db.sync.syncShapeToTable({
+        shape: { url: opts.electricUrl, params: { table: t } },
+        table: t,
+        primaryKey: t === meta ? ["id"] : ["seq"],
+        shapeKey: null
+      })
+    )
+  ) : [];
+  return {
+    clustering: "self",
+    model: "crdt",
+    async read(id) {
+      const rows = await sql`SELECT access::text AS access FROM ${sql(meta)} WHERE id = ${id}`;
+      const row = rows[0];
+      if (!row) return void 0;
+      const doc = docs.get(id) ?? await foldFromCentral(id);
+      return { id, data: b64(doc.encodeState()), accessRules: JSON.parse(row.access) };
+    },
+    async create(id, data, accessRules) {
+      const seedDoc = new StoreValue(data ?? {}, opts.resolveOptions?.(id));
+      const seed = b64(seedDoc.encodeState());
+      const snapshot = seedDoc.getSnapshot();
+      seedDoc.dispose();
+      await sql.begin(async (tx) => {
+        const res = await tx`INSERT INTO ${tx(meta)} (id, access, origin, data)
+          VALUES (${id}, ${asJson(accessRules)}, ${null}, ${asJson(snapshot)})
+          ON CONFLICT (id) DO NOTHING`;
+        if (res.count === 0) throw new SuperLineError("CONFLICT", `Resource already exists: ${id}`);
+        await tx`INSERT INTO ${tx(ups)} (res_id, update, origin) VALUES (${id}, ${seed}, ${null})`;
+      });
+      getDoc(id).applyUpdate(fromB64(seed));
+    },
+    async apply(change) {
+      if (typeof change.update !== "string") {
+        const rows = await sql`SELECT 1 FROM ${sql(meta)} WHERE id = ${change.id}`;
+        if (rows.count === 0) throw new SuperLineError("NOT_FOUND", `No resource: ${change.id}`);
+        withOrigin(change.origin, () => void getDoc(change.id).update(change.update));
+        return;
+      }
+      const res = await sql`INSERT INTO ${sql(ups)} (res_id, update, origin)
+        SELECT ${change.id}, ${change.update}, ${change.origin}
+        WHERE EXISTS (SELECT 1 FROM ${sql(meta)} WHERE id = ${change.id})`;
+      if (res.count === 0) throw new SuperLineError("NOT_FOUND", `No resource: ${change.id}`);
+    },
+    open(id, openOpts) {
+      const doc = getDoc(id);
+      const origin = openOpts?.origin ?? SERVER_ORIGIN;
+      const subs = /* @__PURE__ */ new Set();
+      return {
+        getSnapshot: () => doc.getSnapshot(),
+        subscribe: (cb) => {
+          const off = doc.subscribe(cb);
+          subs.add(off);
+          return () => {
+            off();
+            subs.delete(off);
+          };
+        },
+        set: (value) => withOrigin(origin, () => void doc.set(value)),
+        update: (partial) => withOrigin(origin, () => void doc.update(partial)),
+        // Surgical key removal: read live state, drop the path, set() (diff-and-patch) — the only delete-capable
+        // surface (update MERGES, so it can never remove a key). Atomic in-process.
+        delete: (path) => withOrigin(origin, () => void doc.set(removeAtPath(doc.getSnapshot(), path))),
+        close: () => {
+          for (const off of subs) off();
+          subs.clear();
+        }
+      };
+    },
+    async setAccess(id, accessRules) {
+      const res = await sql`UPDATE ${sql(meta)} SET access = ${asJson(accessRules)} WHERE id = ${id}`;
+      if (res.count === 0) throw new SuperLineError("NOT_FOUND", `No resource: ${id}`);
+    },
+    async delete(id) {
+      await sql.begin(async (tx) => {
+        await tx`DELETE FROM ${tx(meta)} WHERE id = ${id}`;
+        await tx`DELETE FROM ${tx(ups)} WHERE res_id = ${id}`;
+      });
+    },
+    async list() {
+      const rows = await sql`SELECT id FROM ${sql(meta)}`;
+      return rows.map((r) => r.id);
+    },
+    onChange(cb) {
+      changeCbs.add(cb);
+      return () => changeCbs.delete(cb);
+    },
+    onDelete(cb) {
+      deleteCbs.add(cb);
+      return () => deleteCbs.delete(cb);
+    },
+    async close() {
+      for (const t of compactTimers.values()) clearTimeout(t);
+      compactTimers.clear();
+      try {
+        await upsSub.unsubscribe();
+        await metaSub.unsubscribe();
+        for (const s of shapes) s.unsubscribe();
+        if (ownsDb) await db.close();
+      } finally {
+        await sql.end();
+      }
+    }
+  };
+}
+export {
+  syncPgliteStoreServer
+};

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@super-line/store-sync-pglite",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Self-clustering CRDT Store for super-line — an append-only Yjs op-log in central Postgres that ElectricSQL ships to a per-node PGlite replica, folded into in-memory super-store docs. Postgres+Electric is the only fan-out infra; no adapter.",
+  "license": "MIT",
+  "author": "Mert",
+  "keywords": [
+    "super-line",
+    "store",
+    "crdt",
+    "yjs",
+    "pglite",
+    "postgres",
+    "electric",
+    "sync",
+    "self",
+    "collaboration"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mertdogar/super-line.git",
+    "directory": "packages/store-sync-pglite"
+  },
+  "homepage": "https://mertdogar.github.io/super-line/",
+  "bugs": "https://github.com/mertdogar/super-line/issues",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@super-store/store": "^0.3.0",
+    "@electric-sql/pglite": "^0.5.3",
+    "@electric-sql/pglite-sync": "^0.6.3",
+    "postgres": "^3.4.9",
+    "@super-line/core": "^0.8.0"
+  },
+  "devDependencies": {
+    "@electric-sql/pglite-socket": "^0.2.6"
+  },
+  "scripts": {
+    "build": "tsup"
+  }
+}