@fieldnotes/sync-server 0.13.0 → 0.15.0

package/dist/index.d.cts

@@ -1,5 +1,5 @@
 import { CanvasElement } from '@fieldnotes/core';
-import { SyncOp, LayerRecord } from '@fieldnotes/sync';
+import { SyncOp, LayerRecord, FogSnapshot, FogMetaRecord, FogTileRecord } from '@fieldnotes/sync';
 import { WebSocketServer } from 'ws';
 import { IncomingMessage, Server } from 'http';
 
@@ -14,21 +14,27 @@ declare class InMemoryHubFanout implements HubFanout {
     subscribe(handler: (payload: string) => void): () => void;
 }
 
+interface FogApplyResult<T> {
+    readonly accepted: boolean;
+    readonly correction?: T;
+}
+interface FogPatchApplyResult {
+    readonly accepted: FogTileRecord[];
+    readonly corrections: FogTileRecord[];
+}
 interface HubBackend {
+    /** True when every hub instance addresses the same atomic backing state (for example Redis). */
+    readonly sharedAcrossInstances?: boolean;
     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>;
+    fogSnapshot?(room: string): Promise<FogSnapshot | undefined>;
+    applyFogMeta?(room: string, record: FogMetaRecord): Promise<FogApplyResult<FogMetaRecord>>;
+    applyFogTile?(room: string, record: FogTileRecord): Promise<FogApplyResult<FogTileRecord>>;
+    applyFogPatch?(room: string, records: readonly FogTileRecord[]): Promise<FogPatchApplyResult>;
 }
 
 type OwnedElement = CanvasElement & {
@@ -67,6 +73,16 @@ interface ReadContext {
     audience: string | undefined;
 }
 type CanRead = (ctx: ReadContext) => boolean;
+interface AuthorizeFogContext {
+    userId?: string;
+    role?: string;
+    room: string;
+    op: Extract<SyncOp, {
+        kind: 'fog-meta' | 'fog-patch';
+    }>;
+    current: FogSnapshot | undefined;
+}
+type AuthorizeFog = (ctx: AuthorizeFogContext) => boolean | Promise<boolean>;
 
 interface Connection {
     id: string;
@@ -81,6 +97,7 @@ interface SyncHubOptions {
     instanceId?: string;
     authorize?: Authorize;
     authorizeLayer?: AuthorizeLayer;
+    authorizeFog?: AuthorizeFog;
     canRead?: CanRead;
     maxJsonDepth?: number;
     presenceThrottleMs?: number;
@@ -97,9 +114,10 @@ declare class SyncHub {
     private readonly fanoutUnsub;
     private readonly authorize?;
     private readonly authorizeLayer?;
+    private readonly authorizeFog?;
     private readonly canRead?;
-    /** Fallback layer-record store for backends without layer persistence. */
     private readonly memoryLayers;
+    private readonly memoryFog;
     private readonly maxJsonDepth;
     private readonly presenceThrottleMs;
     private readonly maxPresenceLanes;
@@ -137,6 +155,12 @@ declare class SyncHub {
     private getLayerRecords;
     private getLayerRecord;
     private applyLayerRecord;
+    private fogBackend;
+    private getFogLedger;
+    private getFogSnapshot;
+    private applyFogMeta;
+    private applyFogPatch;
+    private processFogOp;
     private mayRead;
     private safePublish;
     private relayToRoom;
@@ -149,12 +173,14 @@ declare class SyncHub {
     private sendCorrection;
     private onFanout;
     private applyFanoutLayerOp;
+    private applyFanoutFogOp;
     close(): void;
 }
 
 declare class MemoryHubBackend implements HubBackend {
     private rooms;
     private roomLayers;
+    private roomFog;
     private room;
     private layers;
     snapshot(room: string): Promise<CanvasElement[]>;
@@ -163,6 +189,11 @@ declare class MemoryHubBackend implements HubBackend {
     layerRecords(room: string): Promise<LayerRecord[]>;
     getLayerRecord(room: string, id: string): Promise<LayerRecord | undefined>;
     applyLayerRecord(room: string, record: LayerRecord): Promise<void>;
+    private fog;
+    fogSnapshot(room: string): Promise<FogSnapshot | undefined>;
+    applyFogMeta(room: string, record: FogMetaRecord): Promise<FogApplyResult<FogMetaRecord>>;
+    applyFogTile(room: string, record: FogTileRecord): Promise<FogApplyResult<FogTileRecord>>;
+    applyFogPatch(room: string, records: readonly FogTileRecord[]): Promise<FogPatchApplyResult>;
 }
 
 interface AuthInfo {
@@ -184,6 +215,7 @@ interface CreateSyncServerOptions {
     authenticate?: Authenticate;
     authorize?: Authorize;
     authorizeLayer?: AuthorizeLayer;
+    authorizeFog?: AuthorizeFog;
     canRead?: CanRead;
     heartbeatIntervalMs?: number;
     maxMessageBytes?: number;
@@ -216,4 +248,32 @@ interface Heartbeat {
 }
 declare function startHeartbeat(wss: HeartbeatServer, intervalMs: number): Heartbeat;
 
-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 };
+interface ApplyResult {
+    accepted: SyncOp | null;
+    corrections: SyncOp[];
+    broadcast?: SyncOp[];
+    locality?: 'shared' | 'local';
+}
+interface ServerOpContext {
+    readonly room: string;
+    readonly sender: string;
+    readonly backend: HubBackend;
+}
+type ServerNext = () => Promise<ApplyResult>;
+interface ServerSyncPlugin {
+    readonly name: string;
+    readonly ownedLegacyKinds?: string[];
+    process?(op: SyncOp, ctx: ServerOpContext, next: ServerNext): Promise<ApplyResult>;
+    snapshot?(room: string, backend: HubBackend): Promise<PluginSnapshot>;
+    filterSnapshot?(snapshot: PluginSnapshot, viewer: {
+        userId: string;
+        role: string;
+    }): PluginSnapshot | null;
+}
+interface PluginSnapshot {
+    readonly pluginName: string;
+    readonly version: number;
+    readonly data: unknown;
+}
+
+export { type ApplyResult, type AuthInfo, type AuthResult, type Authenticate, type Authorize, type AuthorizeContext, type AuthorizeFog, type AuthorizeFogContext, type AuthorizeLayer, type AuthorizeLayerContext, type CanRead, type Connection, type CreateSyncServerOptions, type FogApplyResult, type FogPatchApplyResult, type Heartbeat, type HeartbeatServer, type HeartbeatSocket, type HubBackend, type HubFanout, InMemoryHubFanout, MemoryHubBackend, type OwnedElement, type PluginSnapshot, type ReadContext, type ServerNext, type ServerOpContext, type ServerSyncPlugin, SyncHub, type SyncHubOptions, createSyncServer, startHeartbeat };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { CanvasElement } from '@fieldnotes/core';
-import { SyncOp, LayerRecord } from '@fieldnotes/sync';
+import { SyncOp, LayerRecord, FogSnapshot, FogMetaRecord, FogTileRecord } from '@fieldnotes/sync';
 import { WebSocketServer } from 'ws';
 import { IncomingMessage, Server } from 'http';
 
@@ -14,21 +14,27 @@ declare class InMemoryHubFanout implements HubFanout {
     subscribe(handler: (payload: string) => void): () => void;
 }
 
+interface FogApplyResult<T> {
+    readonly accepted: boolean;
+    readonly correction?: T;
+}
+interface FogPatchApplyResult {
+    readonly accepted: FogTileRecord[];
+    readonly corrections: FogTileRecord[];
+}
 interface HubBackend {
+    /** True when every hub instance addresses the same atomic backing state (for example Redis). */
+    readonly sharedAcrossInstances?: boolean;
     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>;
+    fogSnapshot?(room: string): Promise<FogSnapshot | undefined>;
+    applyFogMeta?(room: string, record: FogMetaRecord): Promise<FogApplyResult<FogMetaRecord>>;
+    applyFogTile?(room: string, record: FogTileRecord): Promise<FogApplyResult<FogTileRecord>>;
+    applyFogPatch?(room: string, records: readonly FogTileRecord[]): Promise<FogPatchApplyResult>;
 }
 
 type OwnedElement = CanvasElement & {
@@ -67,6 +73,16 @@ interface ReadContext {
     audience: string | undefined;
 }
 type CanRead = (ctx: ReadContext) => boolean;
+interface AuthorizeFogContext {
+    userId?: string;
+    role?: string;
+    room: string;
+    op: Extract<SyncOp, {
+        kind: 'fog-meta' | 'fog-patch';
+    }>;
+    current: FogSnapshot | undefined;
+}
+type AuthorizeFog = (ctx: AuthorizeFogContext) => boolean | Promise<boolean>;
 
 interface Connection {
     id: string;
@@ -81,6 +97,7 @@ interface SyncHubOptions {
     instanceId?: string;
     authorize?: Authorize;
     authorizeLayer?: AuthorizeLayer;
+    authorizeFog?: AuthorizeFog;
     canRead?: CanRead;
     maxJsonDepth?: number;
     presenceThrottleMs?: number;
@@ -97,9 +114,10 @@ declare class SyncHub {
     private readonly fanoutUnsub;
     private readonly authorize?;
     private readonly authorizeLayer?;
+    private readonly authorizeFog?;
     private readonly canRead?;
-    /** Fallback layer-record store for backends without layer persistence. */
     private readonly memoryLayers;
+    private readonly memoryFog;
     private readonly maxJsonDepth;
     private readonly presenceThrottleMs;
     private readonly maxPresenceLanes;
@@ -137,6 +155,12 @@ declare class SyncHub {
     private getLayerRecords;
     private getLayerRecord;
     private applyLayerRecord;
+    private fogBackend;
+    private getFogLedger;
+    private getFogSnapshot;
+    private applyFogMeta;
+    private applyFogPatch;
+    private processFogOp;
     private mayRead;
     private safePublish;
     private relayToRoom;
@@ -149,12 +173,14 @@ declare class SyncHub {
     private sendCorrection;
     private onFanout;
     private applyFanoutLayerOp;
+    private applyFanoutFogOp;
     close(): void;
 }
 
 declare class MemoryHubBackend implements HubBackend {
     private rooms;
     private roomLayers;
+    private roomFog;
     private room;
     private layers;
     snapshot(room: string): Promise<CanvasElement[]>;
@@ -163,6 +189,11 @@ declare class MemoryHubBackend implements HubBackend {
     layerRecords(room: string): Promise<LayerRecord[]>;
     getLayerRecord(room: string, id: string): Promise<LayerRecord | undefined>;
     applyLayerRecord(room: string, record: LayerRecord): Promise<void>;
+    private fog;
+    fogSnapshot(room: string): Promise<FogSnapshot | undefined>;
+    applyFogMeta(room: string, record: FogMetaRecord): Promise<FogApplyResult<FogMetaRecord>>;
+    applyFogTile(room: string, record: FogTileRecord): Promise<FogApplyResult<FogTileRecord>>;
+    applyFogPatch(room: string, records: readonly FogTileRecord[]): Promise<FogPatchApplyResult>;
 }
 
 interface AuthInfo {
@@ -184,6 +215,7 @@ interface CreateSyncServerOptions {
     authenticate?: Authenticate;
     authorize?: Authorize;
     authorizeLayer?: AuthorizeLayer;
+    authorizeFog?: AuthorizeFog;
     canRead?: CanRead;
     heartbeatIntervalMs?: number;
     maxMessageBytes?: number;
@@ -216,4 +248,32 @@ interface Heartbeat {
 }
 declare function startHeartbeat(wss: HeartbeatServer, intervalMs: number): Heartbeat;
 
-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 };
+interface ApplyResult {
+    accepted: SyncOp | null;
+    corrections: SyncOp[];
+    broadcast?: SyncOp[];
+    locality?: 'shared' | 'local';
+}
+interface ServerOpContext {
+    readonly room: string;
+    readonly sender: string;
+    readonly backend: HubBackend;
+}
+type ServerNext = () => Promise<ApplyResult>;
+interface ServerSyncPlugin {
+    readonly name: string;
+    readonly ownedLegacyKinds?: string[];
+    process?(op: SyncOp, ctx: ServerOpContext, next: ServerNext): Promise<ApplyResult>;
+    snapshot?(room: string, backend: HubBackend): Promise<PluginSnapshot>;
+    filterSnapshot?(snapshot: PluginSnapshot, viewer: {
+        userId: string;
+        role: string;
+    }): PluginSnapshot | null;
+}
+interface PluginSnapshot {
+    readonly pluginName: string;
+    readonly version: number;
+    readonly data: unknown;
+}
+
+export { type ApplyResult, type AuthInfo, type AuthResult, type Authenticate, type Authorize, type AuthorizeContext, type AuthorizeFog, type AuthorizeFogContext, type AuthorizeLayer, type AuthorizeLayerContext, type CanRead, type Connection, type CreateSyncServerOptions, type FogApplyResult, type FogPatchApplyResult, type Heartbeat, type HeartbeatServer, type HeartbeatSocket, type HubBackend, type HubFanout, InMemoryHubFanout, MemoryHubBackend, type OwnedElement, type PluginSnapshot, type ReadContext, type ServerNext, type ServerOpContext, type ServerSyncPlugin, SyncHub, type SyncHubOptions, createSyncServer, startHeartbeat };

package/dist/index.js

@@ -2,14 +2,19 @@
 import {
   parseEnvelope,
   isValidElement,
-  isNewerLayerRecord
+  isNewerLayerRecord,
+  FogLedger as FogLedger2
 } from "@fieldnotes/sync";
 
 // src/memory-hub-backend.ts
-import { applyOpToMap } from "@fieldnotes/sync";
+import {
+  applyOpToMap,
+  FogLedger
+} from "@fieldnotes/sync";
 var MemoryHubBackend = class {
   rooms = /* @__PURE__ */ new Map();
   roomLayers = /* @__PURE__ */ new Map();
+  roomFog = /* @__PURE__ */ new Map();
   room(id) {
     let r = this.rooms.get(id);
     if (!r) {
@@ -48,6 +53,26 @@ var MemoryHubBackend = class {
   async applyLayerRecord(room, record) {
     this.layers(room).set(record.id, record);
   }
+  fog(room) {
+    let ledger = this.roomFog.get(room);
+    if (!ledger) {
+      ledger = new FogLedger();
+      this.roomFog.set(room, ledger);
+    }
+    return ledger;
+  }
+  async fogSnapshot(room) {
+    return this.fog(room).snapshot();
+  }
+  async applyFogMeta(room, record) {
+    return this.fog(room).applyMeta(record);
+  }
+  async applyFogTile(room, record) {
+    return this.fog(room).applyTile(record);
+  }
+  async applyFogPatch(room, records) {
+    return this.fog(room).applyPatch(records);
+  }
 };
 
 // src/hub-fanout.ts
@@ -162,6 +187,11 @@ function isPresenceOp(op) {
   const k = op.kind;
   return k === "presence" || k === "presence-leave";
 }
+function isFogOp(op) {
+  if (typeof op !== "object" || op === null) return false;
+  const k = op.kind;
+  return k === "fog-meta" || k === "fog-patch";
+}
 var SyncHub = class {
   backend;
   conns = /* @__PURE__ */ new Map();
@@ -175,9 +205,10 @@ var SyncHub = class {
   fanoutUnsub;
   authorize;
   authorizeLayer;
+  authorizeFog;
   canRead;
-  /** Fallback layer-record store for backends without layer persistence. */
   memoryLayers = /* @__PURE__ */ new Map();
+  memoryFog = /* @__PURE__ */ new Map();
   maxJsonDepth;
   presenceThrottleMs;
   maxPresenceLanes;
@@ -193,10 +224,21 @@ var SyncHub = class {
   presenceLanes = /* @__PURE__ */ new Map();
   constructor(options = {}) {
     this.backend = options.backend ?? new MemoryHubBackend();
+    const fogMethods = [
+      this.backend.fogSnapshot,
+      this.backend.applyFogMeta,
+      this.backend.applyFogPatch
+    ];
+    if ((fogMethods.some(Boolean) || Boolean(this.backend.applyFogTile)) && !fogMethods.every(Boolean)) {
+      throw new Error(
+        "HubBackend fog support is an all-or-none capability: fogSnapshot, applyFogMeta, and applyFogPatch are required"
+      );
+    }
     this.instanceId = options.instanceId ?? generateInstanceId();
     this.fanout = options.fanout ?? new InMemoryHubFanout();
     this.authorize = options.authorize;
     this.authorizeLayer = options.authorizeLayer;
+    this.authorizeFog = options.authorizeFog;
     this.canRead = options.canRead;
     this.maxJsonDepth = options.maxJsonDepth ?? DEFAULT_MAX_JSON_DEPTH;
     this.presenceThrottleMs = options.presenceThrottleMs ?? DEFAULT_PRESENCE_THROTTLE_MS;
@@ -273,16 +315,19 @@ var SyncHub = class {
       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: layers.length > 0 ? { kind: "snapshot", to: env.from, elements, layers } : { kind: "snapshot", to: env.from, elements }
-        })
-      );
+      const fog = await this.getFogSnapshot(conn.room);
+      const snapshotOp = {
+        kind: "snapshot",
+        to: env.from,
+        elements
+      };
+      if (layers.length > 0) snapshotOp["layers"] = layers;
+      if (fog) snapshotOp["fog"] = fog;
+      conn.send(JSON.stringify({ from: HUB_FROM, op: snapshotOp }));
     } else if (op.kind === "layer-upsert" || op.kind === "layer-remove") {
       await this.processLayerOp(conn, op);
+    } else if (op.kind === "fog-meta" || op.kind === "fog-patch") {
+      await this.processFogOp(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;
@@ -388,6 +433,121 @@ var SyncHub = class {
     }
     map.set(record.id, record);
   }
+  // ── Fog processing ──
+  fogBackend() {
+    const { fogSnapshot, applyFogMeta, applyFogPatch } = this.backend;
+    if (!fogSnapshot || !applyFogMeta || !applyFogPatch) return null;
+    return {
+      fogSnapshot: fogSnapshot.bind(this.backend),
+      applyFogMeta: applyFogMeta.bind(this.backend),
+      applyFogPatch: applyFogPatch.bind(this.backend)
+    };
+  }
+  getFogLedger(room) {
+    let ledger = this.memoryFog.get(room);
+    if (!ledger) {
+      ledger = new FogLedger2();
+      this.memoryFog.set(room, ledger);
+    }
+    return ledger;
+  }
+  async getFogSnapshot(room) {
+    const backend = this.fogBackend();
+    if (backend) return backend.fogSnapshot(room);
+    return this.getFogLedger(room).snapshot();
+  }
+  async applyFogMeta(room, record) {
+    const backend = this.fogBackend();
+    if (backend) return backend.applyFogMeta(room, record);
+    return this.getFogLedger(room).applyMeta(record);
+  }
+  async applyFogPatch(room, records) {
+    const backend = this.fogBackend();
+    if (backend) return backend.applyFogPatch(room, records);
+    return this.getFogLedger(room).applyPatch(records);
+  }
+  async processFogOp(conn, op) {
+    const current = await this.getFogSnapshot(conn.room);
+    if (this.authorizeFog) {
+      const allowed = await this.authorizeFog({
+        userId: conn.userId,
+        role: conn.role,
+        room: conn.room,
+        op,
+        current
+      });
+      if (!allowed) {
+        if (op.kind === "fog-meta") {
+          const correction = current?.meta ?? { version: 1, editor: HUB_FROM };
+          conn.send(
+            JSON.stringify({ from: HUB_FROM, op: { kind: "fog-meta", record: correction } })
+          );
+        } else if (current?.meta.definition) {
+          const corrections = op.tiles.map((t) => {
+            const existing = current.tiles.find((ct) => ct.x === t.x && ct.y === t.y);
+            return existing ?? {
+              generation: current.meta.definition?.generation ?? op.generation,
+              x: t.x,
+              y: t.y,
+              version: 1,
+              editor: HUB_FROM
+            };
+          });
+          conn.send(
+            JSON.stringify({
+              from: HUB_FROM,
+              op: {
+                kind: "fog-patch",
+                generation: current.meta.definition.generation,
+                tiles: corrections
+              }
+            })
+          );
+        } else {
+          conn.send(
+            JSON.stringify({
+              from: HUB_FROM,
+              op: {
+                kind: "fog-meta",
+                record: current?.meta ?? { version: 1, editor: HUB_FROM }
+              }
+            })
+          );
+        }
+        return;
+      }
+    }
+    let outbound;
+    if (op.kind === "fog-meta") {
+      const result = await this.applyFogMeta(conn.room, op.record);
+      if (!result.accepted) {
+        if (result.correction) {
+          conn.send(
+            JSON.stringify({ from: HUB_FROM, op: { kind: "fog-meta", record: result.correction } })
+          );
+        }
+        return;
+      }
+      outbound = op;
+    } else {
+      const { accepted, corrections } = await this.applyFogPatch(conn.room, op.tiles);
+      if (corrections.length > 0) {
+        const correctionGeneration = corrections[0]?.generation ?? op.generation;
+        conn.send(
+          JSON.stringify({
+            from: HUB_FROM,
+            op: { kind: "fog-patch", generation: correctionGeneration, tiles: corrections }
+          })
+        );
+      }
+      if (accepted.length === 0) return;
+      outbound = { kind: "fog-patch", generation: op.generation, tiles: accepted };
+    }
+    await this.fanout.publish(
+      JSON.stringify({ o: this.instanceId, room: conn.room, from: conn.id, op: outbound })
+    );
+    this.relayToRoom(conn.room, conn.id, JSON.stringify({ from: conn.id, op: outbound }));
+  }
   mayRead(conn, audience) {
     if (!this.canRead) return true;
     return this.canRead({ userId: conn.userId, role: conn.role, room: conn.room, audience });
@@ -568,6 +728,25 @@ var SyncHub = class {
       this.relayToRoom(env.room, void 0, JSON.stringify({ from: env.from, op }));
       return;
     }
+    if (isFogOp(op)) {
+      const previous = this.roomQueues.get(env.room) ?? Promise.resolve();
+      const operation = previous.then(async () => {
+        const accepted = await this.applyFanoutFogOp(env.room, op);
+        if (accepted) {
+          this.relayToRoom(
+            env.room,
+            void 0,
+            JSON.stringify({ from: env.from, op: accepted })
+          );
+        }
+      });
+      this.roomQueues.set(
+        env.room,
+        operation.catch(() => {
+        })
+      );
+      return;
+    }
     if (!isFanoutOp(op)) return;
     const prevAudience = typeof env.prev === "string" ? env.prev : void 0;
     const prevExisted = env.existed === true;
@@ -579,6 +758,15 @@ var SyncHub = class {
     if (current && !isNewerLayerRecord(record, current)) return;
     await this.applyLayerRecord(room, record);
   }
+  async applyFanoutFogOp(room, op) {
+    if (this.backend.sharedAcrossInstances === true && this.fogBackend()) return op;
+    if (op.kind === "fog-meta") {
+      const result = await this.applyFogMeta(room, op.record);
+      return result.accepted ? op : null;
+    }
+    const { accepted } = await this.applyFogPatch(room, op.tiles);
+    return accepted.length > 0 ? { ...op, tiles: accepted } : null;
+  }
   close() {
     for (const connId of [...this.presenceLanes.keys()]) this.clearPresenceLanes(connId);
     this.fanoutUnsub();
@@ -669,6 +857,7 @@ function createSyncServer(options = {}) {
     instanceId: options.instanceId,
     authorize: options.authorize,
     authorizeLayer: options.authorizeLayer,
+    authorizeFog: options.authorizeFog,
     canRead: options.canRead,
     maxJsonDepth: options.maxJsonDepth ?? DEFAULT_MAX_JSON_DEPTH,
     presenceThrottleMs: options.presenceThrottleMs ?? DEFAULT_PRESENCE_THROTTLE_MS,