@fieldnotes/sync-server 0.11.0 → 0.13.0

package/dist/index.d.cts

@@ -1,5 +1,5 @@
 import { CanvasElement } from '@fieldnotes/core';
-import { SyncOp } from '@fieldnotes/sync';
+import { SyncOp, LayerRecord } from '@fieldnotes/sync';
 import { WebSocketServer } from 'ws';
 import { IncomingMessage, Server } from 'http';
 
@@ -18,6 +18,17 @@ interface HubBackend {
     snapshot(room: string): Promise<CanvasElement[]>;
     get(room: string, id: string): Promise<CanvasElement | undefined>;
     apply(room: string, op: SyncOp): Promise<void>;
+    /**
+     * Optional versioned layer-definition persistence. The three methods are
+     * additive and must be implemented together; when absent, the hub keeps
+     * per-room layer records in its own memory (they then live and die with the
+     * hub instance, while elements keep whatever durability the backend has).
+     * Records include removal tombstones. An element `clear` op never touches
+     * layer records.
+     */
+    layerRecords?(room: string): Promise<LayerRecord[]>;
+    getLayerRecord?(room: string, id: string): Promise<LayerRecord | undefined>;
+    applyLayerRecord?(room: string, record: LayerRecord): Promise<void>;
 }
 
 type OwnedElement = CanvasElement & {
@@ -32,6 +43,23 @@ interface AuthorizeContext {
     currentElement?: OwnedElement;
 }
 type Authorize = (ctx: AuthorizeContext) => boolean | Promise<boolean>;
+interface AuthorizeLayerContext {
+    userId?: string;
+    role?: string;
+    room: string;
+    op: Extract<SyncOp, {
+        kind: 'layer-upsert' | 'layer-remove';
+    }>;
+    /** The hub's current record for the target layer, tombstones included. */
+    currentRecord?: LayerRecord;
+}
+/**
+ * Authorizes layer-definition edits. Without a hook every room member may
+ * edit layer definitions. A denied edit is answered with an authoritative
+ * hub correction to the sender only, so the sender's local ledger converges
+ * back to the room state.
+ */
+type AuthorizeLayer = (ctx: AuthorizeLayerContext) => boolean | Promise<boolean>;
 interface ReadContext {
     userId?: string;
     role?: string;
@@ -52,9 +80,11 @@ interface SyncHubOptions {
     fanout?: HubFanout;
     instanceId?: string;
     authorize?: Authorize;
+    authorizeLayer?: AuthorizeLayer;
     canRead?: CanRead;
     maxJsonDepth?: number;
     presenceThrottleMs?: number;
+    maxPresenceLanes?: number;
 }
 declare class SyncHub {
     private readonly backend;
@@ -66,11 +96,23 @@ declare class SyncHub {
     private readonly fanout;
     private readonly fanoutUnsub;
     private readonly authorize?;
+    private readonly authorizeLayer?;
     private readonly canRead?;
+    /** Fallback layer-record store for backends without layer persistence. */
+    private readonly memoryLayers;
     private readonly maxJsonDepth;
     private readonly presenceThrottleMs;
-    private readonly lastPresenceAt;
-    private readonly pendingPresence;
+    private readonly maxPresenceLanes;
+    /**
+     * Presence throttle state keyed by connection, then by lane. A lane is the
+     * payload's `kind` (a non-empty string of at most 64 chars) or the reserved
+     * fallback lane `''`, so a rapid stream of one kind (awareness cursors) can
+     * never replace a pending frame of another kind (a ping, a path `cleared`).
+     * Within a lane the newest payload wins. The lane count per connection is
+     * capped by `maxPresenceLanes`, counting the fallback lane, so a client
+     * cannot mint timers by varying `kind`.
+     */
+    private readonly presenceLanes;
     constructor(options?: SyncHubOptions);
     addConnection(conn: Connection): void;
     removeConnection(connId: string): void;
@@ -83,24 +125,44 @@ declare class SyncHub {
     broadcastPresence<T>(room: string, data: T): number;
     handleMessage(connId: string, message: string): Promise<void>;
     private process;
+    /**
+     * Applies a layer-definition edit on the room's serial queue. Convergence is
+     * last-writer-wins under the deterministic (version, editor) ordering — the
+     * same rule every client applies — so arrival order never decides a race. A
+     * stale or denied edit is answered with an authoritative correction to the
+     * sender only.
+     */
+    private processLayerOp;
+    private layerBackend;
+    private getLayerRecords;
+    private getLayerRecord;
+    private applyLayerRecord;
     private mayRead;
     private safePublish;
     private relayToRoom;
     private broadcastClientPresence;
+    private clearPresenceLanes;
     private schedulePresence;
+    private presenceLaneFor;
     private broadcastLeave;
     private deliverToRoom;
     private sendCorrection;
     private onFanout;
+    private applyFanoutLayerOp;
     close(): void;
 }
 
 declare class MemoryHubBackend implements HubBackend {
     private rooms;
+    private roomLayers;
     private room;
+    private layers;
     snapshot(room: string): Promise<CanvasElement[]>;
     get(room: string, id: string): Promise<CanvasElement | undefined>;
     apply(room: string, op: SyncOp): Promise<void>;
+    layerRecords(room: string): Promise<LayerRecord[]>;
+    getLayerRecord(room: string, id: string): Promise<LayerRecord | undefined>;
+    applyLayerRecord(room: string, record: LayerRecord): Promise<void>;
 }
 
 interface AuthInfo {
@@ -121,6 +183,7 @@ interface CreateSyncServerOptions {
     instanceId?: string;
     authenticate?: Authenticate;
     authorize?: Authorize;
+    authorizeLayer?: AuthorizeLayer;
     canRead?: CanRead;
     heartbeatIntervalMs?: number;
     maxMessageBytes?: number;
@@ -130,6 +193,7 @@ interface CreateSyncServerOptions {
     messagesPerSecond?: number;
     messageBurst?: number;
     presenceThrottleMs?: number;
+    maxPresenceLanes?: number;
     shutdownGraceMs?: number;
 }
 declare function createSyncServer(options?: CreateSyncServerOptions): {
@@ -152,4 +216,4 @@ interface Heartbeat {
 }
 declare function startHeartbeat(wss: HeartbeatServer, intervalMs: number): Heartbeat;
 
-export { type AuthInfo, type AuthResult, type Authenticate, type Authorize, type AuthorizeContext, type CanRead, type Connection, type CreateSyncServerOptions, type Heartbeat, type HeartbeatServer, type HeartbeatSocket, type HubBackend, type HubFanout, InMemoryHubFanout, MemoryHubBackend, type OwnedElement, type ReadContext, SyncHub, type SyncHubOptions, createSyncServer, startHeartbeat };
+export { type AuthInfo, type AuthResult, type Authenticate, type Authorize, type AuthorizeContext, type AuthorizeLayer, type AuthorizeLayerContext, type CanRead, type Connection, type CreateSyncServerOptions, type Heartbeat, type HeartbeatServer, type HeartbeatSocket, type HubBackend, type HubFanout, InMemoryHubFanout, MemoryHubBackend, type OwnedElement, type ReadContext, SyncHub, type SyncHubOptions, createSyncServer, startHeartbeat };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { CanvasElement } from '@fieldnotes/core';
-import { SyncOp } from '@fieldnotes/sync';
+import { SyncOp, LayerRecord } from '@fieldnotes/sync';
 import { WebSocketServer } from 'ws';
 import { IncomingMessage, Server } from 'http';
 
@@ -18,6 +18,17 @@ interface HubBackend {
     snapshot(room: string): Promise<CanvasElement[]>;
     get(room: string, id: string): Promise<CanvasElement | undefined>;
     apply(room: string, op: SyncOp): Promise<void>;
+    /**
+     * Optional versioned layer-definition persistence. The three methods are
+     * additive and must be implemented together; when absent, the hub keeps
+     * per-room layer records in its own memory (they then live and die with the
+     * hub instance, while elements keep whatever durability the backend has).
+     * Records include removal tombstones. An element `clear` op never touches
+     * layer records.
+     */
+    layerRecords?(room: string): Promise<LayerRecord[]>;
+    getLayerRecord?(room: string, id: string): Promise<LayerRecord | undefined>;
+    applyLayerRecord?(room: string, record: LayerRecord): Promise<void>;
 }
 
 type OwnedElement = CanvasElement & {
@@ -32,6 +43,23 @@ interface AuthorizeContext {
     currentElement?: OwnedElement;
 }
 type Authorize = (ctx: AuthorizeContext) => boolean | Promise<boolean>;
+interface AuthorizeLayerContext {
+    userId?: string;
+    role?: string;
+    room: string;
+    op: Extract<SyncOp, {
+        kind: 'layer-upsert' | 'layer-remove';
+    }>;
+    /** The hub's current record for the target layer, tombstones included. */
+    currentRecord?: LayerRecord;
+}
+/**
+ * Authorizes layer-definition edits. Without a hook every room member may
+ * edit layer definitions. A denied edit is answered with an authoritative
+ * hub correction to the sender only, so the sender's local ledger converges
+ * back to the room state.
+ */
+type AuthorizeLayer = (ctx: AuthorizeLayerContext) => boolean | Promise<boolean>;
 interface ReadContext {
     userId?: string;
     role?: string;
@@ -52,9 +80,11 @@ interface SyncHubOptions {
     fanout?: HubFanout;
     instanceId?: string;
     authorize?: Authorize;
+    authorizeLayer?: AuthorizeLayer;
     canRead?: CanRead;
     maxJsonDepth?: number;
     presenceThrottleMs?: number;
+    maxPresenceLanes?: number;
 }
 declare class SyncHub {
     private readonly backend;
@@ -66,11 +96,23 @@ declare class SyncHub {
     private readonly fanout;
     private readonly fanoutUnsub;
     private readonly authorize?;
+    private readonly authorizeLayer?;
     private readonly canRead?;
+    /** Fallback layer-record store for backends without layer persistence. */
+    private readonly memoryLayers;
     private readonly maxJsonDepth;
     private readonly presenceThrottleMs;
-    private readonly lastPresenceAt;
-    private readonly pendingPresence;
+    private readonly maxPresenceLanes;
+    /**
+     * Presence throttle state keyed by connection, then by lane. A lane is the
+     * payload's `kind` (a non-empty string of at most 64 chars) or the reserved
+     * fallback lane `''`, so a rapid stream of one kind (awareness cursors) can
+     * never replace a pending frame of another kind (a ping, a path `cleared`).
+     * Within a lane the newest payload wins. The lane count per connection is
+     * capped by `maxPresenceLanes`, counting the fallback lane, so a client
+     * cannot mint timers by varying `kind`.
+     */
+    private readonly presenceLanes;
     constructor(options?: SyncHubOptions);
     addConnection(conn: Connection): void;
     removeConnection(connId: string): void;
@@ -83,24 +125,44 @@ declare class SyncHub {
     broadcastPresence<T>(room: string, data: T): number;
     handleMessage(connId: string, message: string): Promise<void>;
     private process;
+    /**
+     * Applies a layer-definition edit on the room's serial queue. Convergence is
+     * last-writer-wins under the deterministic (version, editor) ordering — the
+     * same rule every client applies — so arrival order never decides a race. A
+     * stale or denied edit is answered with an authoritative correction to the
+     * sender only.
+     */
+    private processLayerOp;
+    private layerBackend;
+    private getLayerRecords;
+    private getLayerRecord;
+    private applyLayerRecord;
     private mayRead;
     private safePublish;
     private relayToRoom;
     private broadcastClientPresence;
+    private clearPresenceLanes;
     private schedulePresence;
+    private presenceLaneFor;
     private broadcastLeave;
     private deliverToRoom;
     private sendCorrection;
     private onFanout;
+    private applyFanoutLayerOp;
     close(): void;
 }
 
 declare class MemoryHubBackend implements HubBackend {
     private rooms;
+    private roomLayers;
     private room;
+    private layers;
     snapshot(room: string): Promise<CanvasElement[]>;
     get(room: string, id: string): Promise<CanvasElement | undefined>;
     apply(room: string, op: SyncOp): Promise<void>;
+    layerRecords(room: string): Promise<LayerRecord[]>;
+    getLayerRecord(room: string, id: string): Promise<LayerRecord | undefined>;
+    applyLayerRecord(room: string, record: LayerRecord): Promise<void>;
 }
 
 interface AuthInfo {
@@ -121,6 +183,7 @@ interface CreateSyncServerOptions {
     instanceId?: string;
     authenticate?: Authenticate;
     authorize?: Authorize;
+    authorizeLayer?: AuthorizeLayer;
     canRead?: CanRead;
     heartbeatIntervalMs?: number;
     maxMessageBytes?: number;
@@ -130,6 +193,7 @@ interface CreateSyncServerOptions {
     messagesPerSecond?: number;
     messageBurst?: number;
     presenceThrottleMs?: number;
+    maxPresenceLanes?: number;
     shutdownGraceMs?: number;
 }
 declare function createSyncServer(options?: CreateSyncServerOptions): {
@@ -152,4 +216,4 @@ interface Heartbeat {
 }
 declare function startHeartbeat(wss: HeartbeatServer, intervalMs: number): Heartbeat;
 
-export { type AuthInfo, type AuthResult, type Authenticate, type Authorize, type AuthorizeContext, type CanRead, type Connection, type CreateSyncServerOptions, type Heartbeat, type HeartbeatServer, type HeartbeatSocket, type HubBackend, type HubFanout, InMemoryHubFanout, MemoryHubBackend, type OwnedElement, type ReadContext, SyncHub, type SyncHubOptions, createSyncServer, startHeartbeat };
+export { type AuthInfo, type AuthResult, type Authenticate, type Authorize, type AuthorizeContext, type AuthorizeLayer, type AuthorizeLayerContext, type CanRead, type Connection, type CreateSyncServerOptions, type Heartbeat, type HeartbeatServer, type HeartbeatSocket, type HubBackend, type HubFanout, InMemoryHubFanout, MemoryHubBackend, type OwnedElement, type ReadContext, SyncHub, type SyncHubOptions, createSyncServer, startHeartbeat };

package/dist/index.js

@@ -1,10 +1,15 @@
 // src/sync-hub.ts
-import { parseEnvelope, isValidElement } from "@fieldnotes/sync";
+import {
+  parseEnvelope,
+  isValidElement,
+  isNewerLayerRecord
+} from "@fieldnotes/sync";
 
 // src/memory-hub-backend.ts
 import { applyOpToMap } from "@fieldnotes/sync";
 var MemoryHubBackend = class {
   rooms = /* @__PURE__ */ new Map();
+  roomLayers = /* @__PURE__ */ new Map();
   room(id) {
     let r = this.rooms.get(id);
     if (!r) {
@@ -13,6 +18,14 @@ var MemoryHubBackend = class {
     }
     return r;
   }
+  layers(room) {
+    let r = this.roomLayers.get(room);
+    if (!r) {
+      r = /* @__PURE__ */ new Map();
+      this.roomLayers.set(room, r);
+    }
+    return r;
+  }
   async snapshot(room) {
     return [...this.room(room).values()];
   }
@@ -26,6 +39,15 @@ var MemoryHubBackend = class {
     }
     applyOpToMap(this.room(room), op);
   }
+  async layerRecords(room) {
+    return [...this.layers(room).values()];
+  }
+  async getLayerRecord(room, id) {
+    return this.layers(room).get(id);
+  }
+  async applyLayerRecord(room, record) {
+    this.layers(room).set(record.id, record);
+  }
 };
 
 // src/hub-fanout.ts
@@ -53,6 +75,7 @@ var DEFAULT_MAX_PENDING_AUTH_BYTES = 2 * 1024 * 1024;
 var DEFAULT_MESSAGES_PER_SECOND = 120;
 var DEFAULT_MESSAGE_BURST = 240;
 var DEFAULT_PRESENCE_THROTTLE_MS = 50;
+var DEFAULT_MAX_PRESENCE_LANES = 16;
 function hasJsonDepthAtMost(message, maxDepth) {
   let depth = 0;
   let inString = false;
@@ -108,6 +131,32 @@ function isFanoutOp(op) {
   if (o.kind === "remove") return typeof o.id === "string";
   return o.kind === "clear";
 }
+var FALLBACK_PRESENCE_LANE = "";
+var MAX_PRESENCE_LANE_LENGTH = 64;
+function presenceLaneOf(data) {
+  if (typeof data !== "object" || data === null) return FALLBACK_PRESENCE_LANE;
+  const kind = data.kind;
+  if (typeof kind !== "string" || kind.length === 0 || kind.length > MAX_PRESENCE_LANE_LENGTH) {
+    return FALLBACK_PRESENCE_LANE;
+  }
+  return kind;
+}
+function isLayerOp(op) {
+  if (typeof op !== "object" || op === null) return false;
+  const k = op.kind;
+  return k === "layer-upsert" || k === "layer-remove";
+}
+function layerOpToRecord(op) {
+  return op.kind === "layer-upsert" ? { id: op.layer.id, version: op.version, editor: op.editor, definition: op.layer } : { id: op.id, version: op.version, editor: op.editor };
+}
+function layerRecordToOp(record) {
+  return record.definition ? {
+    kind: "layer-upsert",
+    layer: record.definition,
+    version: record.version,
+    editor: record.editor
+  } : { kind: "layer-remove", id: record.id, version: record.version, editor: record.editor };
+}
 function isPresenceOp(op) {
   if (typeof op !== "object" || op === null) return false;
   const k = op.kind;
@@ -125,19 +174,37 @@ var SyncHub = class {
   fanout;
   fanoutUnsub;
   authorize;
+  authorizeLayer;
   canRead;
+  /** Fallback layer-record store for backends without layer persistence. */
+  memoryLayers = /* @__PURE__ */ new Map();
   maxJsonDepth;
   presenceThrottleMs;
-  lastPresenceAt = /* @__PURE__ */ new Map();
-  pendingPresence = /* @__PURE__ */ new Map();
+  maxPresenceLanes;
+  /**
+   * Presence throttle state keyed by connection, then by lane. A lane is the
+   * payload's `kind` (a non-empty string of at most 64 chars) or the reserved
+   * fallback lane `''`, so a rapid stream of one kind (awareness cursors) can
+   * never replace a pending frame of another kind (a ping, a path `cleared`).
+   * Within a lane the newest payload wins. The lane count per connection is
+   * capped by `maxPresenceLanes`, counting the fallback lane, so a client
+   * cannot mint timers by varying `kind`.
+   */
+  presenceLanes = /* @__PURE__ */ new Map();
   constructor(options = {}) {
     this.backend = options.backend ?? new MemoryHubBackend();
     this.instanceId = options.instanceId ?? generateInstanceId();
     this.fanout = options.fanout ?? new InMemoryHubFanout();
     this.authorize = options.authorize;
+    this.authorizeLayer = options.authorizeLayer;
     this.canRead = options.canRead;
     this.maxJsonDepth = options.maxJsonDepth ?? DEFAULT_MAX_JSON_DEPTH;
     this.presenceThrottleMs = options.presenceThrottleMs ?? DEFAULT_PRESENCE_THROTTLE_MS;
+    const maxPresenceLanes = options.maxPresenceLanes ?? DEFAULT_MAX_PRESENCE_LANES;
+    if (!Number.isFinite(maxPresenceLanes) || maxPresenceLanes < 1) {
+      throw new RangeError("maxPresenceLanes must be a finite number of at least 1");
+    }
+    this.maxPresenceLanes = Math.floor(maxPresenceLanes);
     this.fanoutUnsub = this.fanout.subscribe((payload) => this.onFanout(payload));
   }
   addConnection(conn) {
@@ -155,10 +222,7 @@ var SyncHub = class {
     this.conns.delete(connId);
     const room = conn.room;
     const hadPresence = this.presenceConnections.delete(connId);
-    this.lastPresenceAt.delete(connId);
-    const pendingPresence = this.pendingPresence.get(connId);
-    if (pendingPresence) clearTimeout(pendingPresence.timer);
-    this.pendingPresence.delete(connId);
+    this.clearPresenceLanes(connId);
     const members = this.rooms.get(room);
     if (members) {
       members.delete(connId);
@@ -208,11 +272,17 @@ var SyncHub = class {
     if (op.kind === "request-snapshot") {
       const all = await this.backend.snapshot(conn.room);
       const elements = this.canRead ? all.filter((el) => this.mayRead(conn, el.audience)) : all;
+      const layers = await this.getLayerRecords(conn.room);
       conn.send(
         // `to` is a private correlation address for the requesting SyncClient. It is never
         // broadcast; every public sender identity below comes from the server-owned connection.
-        JSON.stringify({ from: HUB_FROM, op: { kind: "snapshot", to: env.from, elements } })
+        JSON.stringify({
+          from: HUB_FROM,
+          op: layers.length > 0 ? { kind: "snapshot", to: env.from, elements, layers } : { kind: "snapshot", to: env.from, elements }
+        })
       );
+    } else if (op.kind === "layer-upsert" || op.kind === "layer-remove") {
+      await this.processLayerOp(conn, op);
     } else if (op.kind === "upsert" || op.kind === "remove" || op.kind === "clear") {
       const id = op.kind === "upsert" ? op.element.id : op.kind === "remove" ? op.id : void 0;
       const needCurrent = (this.authorize || this.canRead) && id !== void 0;
@@ -252,6 +322,72 @@ var SyncHub = class {
       this.deliverToRoom(conn.room, conn.id, conn.id, outboundOp, prevAudience, prevExisted);
     }
   }
+  /**
+   * Applies a layer-definition edit on the room's serial queue. Convergence is
+   * last-writer-wins under the deterministic (version, editor) ordering — the
+   * same rule every client applies — so arrival order never decides a race. A
+   * stale or denied edit is answered with an authoritative correction to the
+   * sender only.
+   */
+  async processLayerOp(conn, op) {
+    const record = layerOpToRecord(op);
+    const current = await this.getLayerRecord(conn.room, record.id);
+    if (this.authorizeLayer) {
+      const allowed = await this.authorizeLayer({
+        userId: conn.userId,
+        role: conn.role,
+        room: conn.room,
+        op,
+        currentRecord: current
+      });
+      if (!allowed) {
+        const correction = current ?? { id: record.id, version: record.version, editor: HUB_FROM };
+        conn.send(JSON.stringify({ from: HUB_FROM, op: layerRecordToOp(correction) }));
+        return;
+      }
+    }
+    if (current && !isNewerLayerRecord(record, current)) {
+      conn.send(JSON.stringify({ from: HUB_FROM, op: layerRecordToOp(current) }));
+      return;
+    }
+    await this.applyLayerRecord(conn.room, record);
+    await this.fanout.publish(
+      JSON.stringify({ o: this.instanceId, room: conn.room, from: conn.id, op })
+    );
+    this.relayToRoom(conn.room, conn.id, JSON.stringify({ from: conn.id, op }));
+  }
+  layerBackend() {
+    const { layerRecords, getLayerRecord, applyLayerRecord } = this.backend;
+    if (!layerRecords || !getLayerRecord || !applyLayerRecord) return null;
+    return {
+      layerRecords: layerRecords.bind(this.backend),
+      getLayerRecord: getLayerRecord.bind(this.backend),
+      applyLayerRecord: applyLayerRecord.bind(this.backend)
+    };
+  }
+  async getLayerRecords(room) {
+    const backend = this.layerBackend();
+    if (backend) return backend.layerRecords(room);
+    return [...this.memoryLayers.get(room)?.values() ?? []];
+  }
+  async getLayerRecord(room, id) {
+    const backend = this.layerBackend();
+    if (backend) return backend.getLayerRecord(room, id);
+    return this.memoryLayers.get(room)?.get(id);
+  }
+  async applyLayerRecord(room, record) {
+    const backend = this.layerBackend();
+    if (backend) {
+      await backend.applyLayerRecord(room, record);
+      return;
+    }
+    let map = this.memoryLayers.get(room);
+    if (!map) {
+      map = /* @__PURE__ */ new Map();
+      this.memoryLayers.set(room, map);
+    }
+    map.set(record.id, record);
+  }
   mayRead(conn, audience) {
     if (!this.canRead) return true;
     return this.canRead({ userId: conn.userId, role: conn.role, room: conn.room, audience });
@@ -292,34 +428,63 @@ var SyncHub = class {
       })
     );
   }
+  clearPresenceLanes(connId) {
+    const lanes = this.presenceLanes.get(connId);
+    if (!lanes) return;
+    for (const lane of lanes.values()) {
+      if (lane.pending) clearTimeout(lane.pending.timer);
+    }
+    this.presenceLanes.delete(connId);
+  }
   schedulePresence(conn, data) {
     if (this.presenceThrottleMs <= 0) {
       this.broadcastClientPresence(conn, data);
       return;
     }
+    const lane = this.presenceLaneFor(conn.id, presenceLaneOf(data));
     const now = Date.now();
-    const lastSentAt = this.lastPresenceAt.get(conn.id);
-    if (lastSentAt === void 0 || now - lastSentAt >= this.presenceThrottleMs) {
-      this.lastPresenceAt.set(conn.id, now);
+    if (lane.lastSentAt === void 0 || now - lane.lastSentAt >= this.presenceThrottleMs) {
+      if (lane.pending) {
+        clearTimeout(lane.pending.timer);
+        lane.pending = null;
+      }
+      lane.lastSentAt = now;
       this.broadcastClientPresence(conn, data);
       return;
     }
-    const existing = this.pendingPresence.get(conn.id);
-    if (existing) {
-      existing.data = data;
+    if (lane.pending) {
+      lane.pending.data = data;
       return;
     }
     const timer = setTimeout(
       () => {
-        const pending = this.pendingPresence.get(conn.id);
-        this.pendingPresence.delete(conn.id);
+        const pending = lane.pending;
+        lane.pending = null;
         if (!pending || !this.conns.has(conn.id)) return;
-        this.lastPresenceAt.set(conn.id, Date.now());
+        lane.lastSentAt = Date.now();
         this.broadcastClientPresence(conn, pending.data);
       },
-      this.presenceThrottleMs - (now - lastSentAt)
+      this.presenceThrottleMs - (now - lane.lastSentAt)
     );
-    this.pendingPresence.set(conn.id, { data, timer });
+    lane.pending = { data, timer };
+  }
+  presenceLaneFor(connId, requested) {
+    let lanes = this.presenceLanes.get(connId);
+    if (!lanes) {
+      lanes = /* @__PURE__ */ new Map();
+      this.presenceLanes.set(connId, lanes);
+    }
+    let key = requested;
+    if (key !== FALLBACK_PRESENCE_LANE && !lanes.has(key)) {
+      const named = lanes.size - (lanes.has(FALLBACK_PRESENCE_LANE) ? 1 : 0);
+      if (named >= this.maxPresenceLanes - 1) key = FALLBACK_PRESENCE_LANE;
+    }
+    let lane = lanes.get(key);
+    if (!lane) {
+      lane = { lastSentAt: void 0, pending: null };
+      lanes.set(key, lane);
+    }
+    return lane;
   }
   broadcastLeave(room, from) {
     const message = JSON.stringify({ from, op: { kind: "presence-leave" } });
@@ -397,14 +562,25 @@ var SyncHub = class {
       this.relayToRoom(env.room, void 0, JSON.stringify({ from: env.from, op }));
       return;
     }
+    if (isLayerOp(op)) {
+      void this.applyFanoutLayerOp(env.room, op).catch(() => {
+      });
+      this.relayToRoom(env.room, void 0, JSON.stringify({ from: env.from, op }));
+      return;
+    }
     if (!isFanoutOp(op)) return;
     const prevAudience = typeof env.prev === "string" ? env.prev : void 0;
     const prevExisted = env.existed === true;
     this.deliverToRoom(env.room, void 0, env.from, op, prevAudience, prevExisted);
   }
+  async applyFanoutLayerOp(room, op) {
+    const record = layerOpToRecord(op);
+    const current = await this.getLayerRecord(room, record.id);
+    if (current && !isNewerLayerRecord(record, current)) return;
+    await this.applyLayerRecord(room, record);
+  }
   close() {
-    for (const pending of this.pendingPresence.values()) clearTimeout(pending.timer);
-    this.pendingPresence.clear();
+    for (const connId of [...this.presenceLanes.keys()]) this.clearPresenceLanes(connId);
     this.fanoutUnsub();
   }
 };
@@ -492,9 +668,11 @@ function createSyncServer(options = {}) {
     fanout: options.fanout,
     instanceId: options.instanceId,
     authorize: options.authorize,
+    authorizeLayer: options.authorizeLayer,
     canRead: options.canRead,
     maxJsonDepth: options.maxJsonDepth ?? DEFAULT_MAX_JSON_DEPTH,
-    presenceThrottleMs: options.presenceThrottleMs ?? DEFAULT_PRESENCE_THROTTLE_MS
+    presenceThrottleMs: options.presenceThrottleMs ?? DEFAULT_PRESENCE_THROTTLE_MS,
+    maxPresenceLanes: options.maxPresenceLanes
   });
   const maxMessageBytes = options.maxMessageBytes ?? DEFAULT_MAX_MESSAGE_BYTES;
   const wss = options.server ? new WebSocketServer({ server: options.server, maxPayload: maxMessageBytes }) : new WebSocketServer({ port: options.port ?? 0, maxPayload: maxMessageBytes });