@sveltebase/sync 1.0.0

package/dist/server/broker.js

@@ -0,0 +1,230 @@
+import { parseSyncMessage } from "../protocol.js";
+export class SyncBroker {
+    handlers;
+    connections = new Set();
+    authorizeConnection;
+    constructor(handlers, authorizeConnection) {
+        this.handlers = new Map();
+        this.setHandlers(handlers);
+        this.authorizeConnection = authorizeConnection;
+    }
+    setHandlers(handlers) {
+        this.handlers.clear();
+        for (const h of handlers) {
+            // Resolve static channel to register, or we can register dynamic channel routing
+            // If it's a dynamic channel resolver function, we will match channel prefix or resolve dynamically
+            // Let's support both static channels and dynamic channel prefixes (or lookups).
+            // If config.channel is a function, we register it under a wildcard or handle it dynamically.
+            if (typeof h.config.channel === "string") {
+                this.handlers.set(h.config.channel, h);
+            }
+        }
+    }
+    registerConnection(conn) {
+        this.connections.add(conn);
+    }
+    removeConnection(conn) {
+        this.connections.delete(conn);
+    }
+    /**
+     * Resolves the appropriate handler for a channel name.
+     */
+    findHandler(channel) {
+        // Static match
+        const handler = this.handlers.get(channel);
+        if (handler)
+            return handler;
+        // Dynamic match: check dynamic handlers
+        for (const h of this.handlers.values()) {
+            if (typeof h.config.channel === "function") {
+                // We'll check if it matches in some way, but generally dynamic channel is resolved
+                // during subscribe and stored.
+            }
+        }
+        // Fallback: search all handlers to see if they resolve to this channel for a generic context
+        // (this is rare, usually channels are static or follow a pattern like channel:userId)
+        for (const [, h] of this.handlers) {
+            if (typeof h.config.channel === "function") {
+                // Let's assume dynamic channels are in format "prefix:id". We can match by prefix.
+                const staticChannelPrefix = typeof h.config.channel === "string" ? h.config.channel : "";
+                if (staticChannelPrefix && channel.startsWith(staticChannelPrefix)) {
+                    return h;
+                }
+            }
+        }
+        // Let's support matching prefix like "todos:" -> match the todos handler
+        const colonIndex = channel.indexOf(":");
+        if (colonIndex !== -1) {
+            const prefix = channel.substring(0, colonIndex);
+            const prefixHandler = this.handlers.get(prefix);
+            if (prefixHandler)
+                return prefixHandler;
+        }
+        return undefined;
+    }
+    async handleMessage(conn, rawMessage, platform, request) {
+        const msg = parseSyncMessage(rawMessage);
+        if (!msg)
+            return;
+        const auth = conn.getAuth();
+        const ctx = {
+            platform,
+            request,
+            auth,
+        };
+        try {
+            switch (msg.type) {
+                case "ping":
+                    conn.send("pong");
+                    break;
+                case "subscribe": {
+                    const handler = this.findHandler(msg.channel);
+                    if (!handler) {
+                        conn.send(JSON.stringify({
+                            type: "reject",
+                            id: "subscribe",
+                            error: `No handler registered for channel: ${msg.channel}`,
+                        }));
+                        return;
+                    }
+                    // Channel authorize
+                    if (handler.config.authorize) {
+                        await handler.config.authorize(ctx);
+                    }
+                    conn.getSubscribedChannels().add(msg.channel);
+                    // Fetch snapshot with delta support
+                    const data = await handler.config.fetch(ctx, msg.since);
+                    conn.send(JSON.stringify({
+                        type: "snapshot",
+                        channel: msg.channel,
+                        data,
+                        isDelta: !!msg.since,
+                    }));
+                    break;
+                }
+                case "unsubscribe":
+                    conn.getSubscribedChannels().delete(msg.channel);
+                    break;
+                case "mutate": {
+                    const handler = this.findHandler(msg.channel);
+                    if (!handler) {
+                        conn.send(JSON.stringify({
+                            type: "reject",
+                            id: msg.id,
+                            error: `No handler for channel: ${msg.channel}`,
+                        }));
+                        return;
+                    }
+                    // Authorize mutation
+                    if (handler.config.authorize) {
+                        await handler.config.authorize(ctx);
+                    }
+                    let result;
+                    if (msg.action === "create") {
+                        if (handler.config.validate?.create) {
+                            msg.data = handler.config.validate.create.parse(msg.data);
+                        }
+                        if (!handler.config.create) {
+                            throw new Error(`Forbidden: Create operation not supported on channel ${msg.channel}`);
+                        }
+                        result = await handler.config.create(ctx, msg.data);
+                    }
+                    else if (msg.action === "update") {
+                        if (handler.config.validate?.update) {
+                            msg.data = handler.config.validate.update.parse(msg.data);
+                        }
+                        if (!handler.config.update) {
+                            throw new Error(`Forbidden: Update operation not supported on channel ${msg.channel}`);
+                        }
+                        result = await handler.config.update(ctx, msg.key, msg.data);
+                    }
+                    else if (msg.action === "delete") {
+                        if (!handler.config.delete) {
+                            throw new Error(`Forbidden: Delete operation not supported on channel ${msg.channel}`);
+                        }
+                        await handler.config.delete(ctx, msg.key);
+                        result = { id: msg.key };
+                    }
+                    // Send Ack back to sender
+                    conn.send(JSON.stringify({
+                        type: "ack",
+                        id: msg.id,
+                        data: result,
+                    }));
+                    // Broadcast changes to other subscribers
+                    this.broadcastChange(conn, msg.channel, msg.action, msg.key || result?.id, result, msg.id, handler, ctx);
+                    break;
+                }
+            }
+        }
+        catch (err) {
+            console.error(`SyncBroker: error handling message type=${msg.type}:`, err);
+            if (msg.type === "mutate") {
+                conn.send(JSON.stringify({
+                    type: "reject",
+                    id: msg.id,
+                    error: err.message || "Server error",
+                }));
+            }
+        }
+    }
+    async broadcastChange(sender, channel, action, key, data, mutationId, handler, ctx) {
+        const changeMsg = JSON.stringify({
+            type: "change",
+            channel,
+            action,
+            key,
+            data,
+            mutationId,
+        });
+        // Determine scope
+        let allowedUserIds = "all";
+        if (handler.config.scope) {
+            try {
+                allowedUserIds = await handler.config.scope(ctx, action, data);
+            }
+            catch (e) {
+                console.error("SyncBroker: error resolving broadcast scope:", e);
+            }
+        }
+        for (const conn of this.connections) {
+            // Don't send to connections not subscribed to this channel
+            if (!conn.getSubscribedChannels().has(channel)) {
+                continue;
+            }
+            // Filter based on scope
+            if (allowedUserIds !== "all") {
+                const connAuth = conn.getAuth();
+                const userId = connAuth?.userId;
+                if (!userId || !allowedUserIds.includes(userId)) {
+                    continue;
+                }
+            }
+            try {
+                conn.send(changeMsg);
+            }
+            catch {
+                this.connections.delete(conn);
+            }
+        }
+    }
+    async handleExternalChange(channel, action, key, data) {
+        const changeMsg = JSON.stringify({
+            type: "change",
+            channel,
+            action,
+            key,
+            data,
+        });
+        for (const conn of this.connections) {
+            if (conn.getSubscribedChannels().has(channel)) {
+                try {
+                    conn.send(changeMsg);
+                }
+                catch {
+                    this.connections.delete(conn);
+                }
+            }
+        }
+    }
+}

package/dist/server/dev-engine.d.ts

@@ -0,0 +1,10 @@
+import type { SyncHandler } from "./index.js";
+import type { IncomingMessage } from "node:http";
+export declare function setHandlers(handlers: SyncHandler[]): void;
+export declare function addClient(ws: {
+    send: (data: string) => void;
+    close: (code?: number, reason?: string) => void;
+    on: (event: string, listener: (...args: any[]) => void) => void;
+}, req: IncomingMessage): void;
+export declare function broadcastExternalChange(channel: string, action: "create" | "update" | "delete", key: string | undefined, data: any): Promise<void>;
+//# sourceMappingURL=dev-engine.d.ts.map

package/dist/server/dev-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev-engine.d.ts","sourceRoot":"","sources":["../../src/server/dev-engine.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAUjD,wBAAgB,WAAW,CAAC,QAAQ,EAAE,WAAW,EAAE,QASlD;AAcD,wBAAgB,SAAS,CACvB,EAAE,EAAE;IACF,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC7B,KAAK,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAChD,EAAE,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,KAAK,IAAI,CAAC;CACjE,EACD,GAAG,EAAE,eAAe,QA+ErB;AAyBD,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,QAAQ,GAAG,QAAQ,GAAG,QAAQ,EACtC,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,IAAI,EAAE,GAAG,iBAIV"}

package/dist/server/dev-engine.js

@@ -0,0 +1,117 @@
+import { SyncBroker } from "./broker.js";
+const GLOBAL_KEY = "__sync_dev_broker__";
+let devBroker = null;
+export function setHandlers(handlers) {
+    const g = globalThis;
+    if (!g[GLOBAL_KEY]) {
+        const broker = new SyncBroker(handlers);
+        g[GLOBAL_KEY] = { broker };
+    }
+    else {
+        g[GLOBAL_KEY].broker.setHandlers(handlers);
+    }
+    devBroker = g[GLOBAL_KEY].broker;
+}
+function getDevBroker() {
+    if (devBroker)
+        return devBroker;
+    const g = globalThis;
+    if (g[GLOBAL_KEY]) {
+        devBroker = g[GLOBAL_KEY].broker;
+        return devBroker;
+    }
+    throw new Error("Sync dev broker not initialized. Call setHandlers first.");
+}
+export function addClient(ws, req) {
+    const broker = getDevBroker();
+    const subscribedChannels = new Set();
+    let auth = null;
+    // Convert Node IncomingMessage headers to web-standard Headers
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(req.headers)) {
+        if (value === undefined)
+            continue;
+        if (Array.isArray(value)) {
+            for (const v of value) {
+                headers.append(key, v);
+            }
+        }
+        else {
+            headers.set(key, value);
+        }
+    }
+    const urlObj = new URL(req.url ?? "", `http://${req.headers.host || "localhost"}`);
+    // Align with DO behavior to set local dev auth
+    const userId = urlObj.searchParams.get("userId") || headers.get("x-user-id");
+    if (userId) {
+        auth = { userId };
+    }
+    const conn = {
+        send(data) {
+            ws.send(data);
+        },
+        close(code, reason) {
+            ws.close(code, reason);
+        },
+        getAuth() {
+            return auth;
+        },
+        setAuth(newAuth) {
+            auth = newAuth;
+        },
+        getSubscribedChannels() {
+            return subscribedChannels;
+        },
+        headers,
+        url: urlObj.toString(),
+    };
+    broker.registerConnection(conn);
+    console.log("dev-engine: addClient registered connection");
+    ws.on("message", async (data) => {
+        const messageString = String(data);
+        console.log("dev-engine: WebSocket message received:", messageString.slice(0, 100));
+        const request = new Request(conn.url, {
+            headers: conn.headers,
+        });
+        try {
+            console.log("dev-engine: getting platform proxy...");
+            const platform = await getPlatform();
+            console.log("dev-engine: platform proxy obtained, handling message...");
+            await broker.handleMessage(conn, messageString, platform, request);
+            console.log("dev-engine: message handled successfully");
+        }
+        catch (err) {
+            console.error("dev-engine: Error handling message:", err);
+        }
+    });
+    ws.on("close", () => {
+        console.log("dev-engine: WebSocket connection closed");
+        broker.removeConnection(conn);
+    });
+    ws.on("error", (err) => {
+        console.error("dev-engine: WebSocket connection error:", err);
+        broker.removeConnection(conn);
+    });
+}
+const GLOBAL_PLATFORM_KEY = "__sync_dev_platform__";
+async function getPlatform() {
+    const g = globalThis;
+    if (!g[GLOBAL_PLATFORM_KEY]) {
+        try {
+            console.log("dev-engine: calling getPlatformProxy()...");
+            const startTime = Date.now();
+            const { getPlatformProxy } = await import("wrangler");
+            const platform = await getPlatformProxy();
+            g[GLOBAL_PLATFORM_KEY] = { platform };
+            console.log(`dev-engine: getPlatformProxy() succeeded in ${Date.now() - startTime}ms`);
+        }
+        catch (err) {
+            console.error("dev-engine: Failed to load wrangler platform proxy:", err);
+        }
+    }
+    return g[GLOBAL_PLATFORM_KEY]?.platform;
+}
+export async function broadcastExternalChange(channel, action, key, data) {
+    const broker = getDevBroker();
+    await broker.handleExternalChange(channel, action, key, data);
+}

package/dist/server/engine.d.ts

@@ -0,0 +1,13 @@
+import { DurableObject } from "cloudflare:workers";
+import { SyncBroker } from "./broker.js";
+export declare class SyncEngineBase extends DurableObject<Env> {
+    protected broker: SyncBroker;
+    private connMap;
+    constructor(ctx: DurableObjectState, env: Env, handlers: any[]);
+    fetch(request: Request): Promise<Response>;
+    private connectWebSocket;
+    webSocketMessage(ws: WebSocket, message: string | ArrayBuffer): Promise<void>;
+    webSocketClose(ws: WebSocket, code: number, reason: string): void;
+    webSocketError(ws: WebSocket): void;
+}
+//# sourceMappingURL=engine.d.ts.map

package/dist/server/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/server/engine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,UAAU,EAAwB,MAAM,aAAa,CAAC;AA4C/D,qBAAa,cAAe,SAAQ,aAAa,CAAC,GAAG,CAAC;IACpD,SAAS,CAAC,MAAM,EAAE,UAAU,CAAC;IAC7B,OAAO,CAAC,OAAO,CAAkD;gBAErD,GAAG,EAAE,kBAAkB,EAAE,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE;IAKxD,KAAK,CAAC,OAAO,EAAE,OAAO;IAuB5B,OAAO,CAAC,gBAAgB;IA2BlB,gBAAgB,CAAC,EAAE,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,WAAW;IAiBnE,cAAc,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAa1D,cAAc,CAAC,EAAE,EAAE,SAAS;CAO7B"}

package/dist/server/engine.js

@@ -0,0 +1,117 @@
+import { DurableObject } from "cloudflare:workers";
+import { SyncBroker } from "./broker.js";
+class CloudflareSyncConnection {
+    ws;
+    auth = null;
+    subscribedChannels = new Set();
+    headers;
+    url;
+    constructor(ws, request) {
+        this.ws = ws;
+        this.headers = new Headers(request.headers);
+        this.url = request.url;
+    }
+    send(data) {
+        try {
+            this.ws.send(data);
+        }
+        catch {
+            // Ignore sending to closed sockets
+        }
+    }
+    close(code, reason) {
+        try {
+            this.ws.close(code, reason);
+        }
+        catch {
+            // Ignore errors on close
+        }
+    }
+    getAuth() {
+        return this.auth;
+    }
+    setAuth(newAuth) {
+        this.auth = newAuth;
+    }
+    getSubscribedChannels() {
+        return this.subscribedChannels;
+    }
+}
+export class SyncEngineBase extends DurableObject {
+    broker;
+    connMap = new Map();
+    constructor(ctx, env, handlers) {
+        super(ctx, env);
+        this.broker = new SyncBroker(handlers);
+    }
+    async fetch(request) {
+        const url = new URL(request.url);
+        if (url.pathname === "/websocket") {
+            return this.connectWebSocket(request);
+        }
+        if (url.pathname === "/broadcast" && request.method === "POST") {
+            try {
+                const body = (await request.json());
+                const { channel, action, key, data } = body;
+                await this.broker.handleExternalChange(channel, action, key, data);
+                return new Response(null, { status: 204 });
+            }
+            catch (err) {
+                return new Response(err.message || "Error processing broadcast", {
+                    status: 400,
+                });
+            }
+        }
+        return new Response("Not found", { status: 404 });
+    }
+    connectWebSocket(request) {
+        if (request.headers.get("Upgrade") !== "websocket") {
+            return new Response("Expected Upgrade: websocket", { status: 426 });
+        }
+        const [client, server] = Object.values(new WebSocketPair());
+        this.ctx.acceptWebSocket(server);
+        const conn = new CloudflareSyncConnection(server, request);
+        const url = new URL(request.url);
+        const userId = url.searchParams.get("userId") || request.headers.get("x-user-id");
+        if (userId) {
+            conn.setAuth({ userId });
+        }
+        this.connMap.set(server, conn);
+        this.broker.registerConnection(conn);
+        return new Response(null, {
+            status: 101,
+            webSocket: client,
+        });
+    }
+    async webSocketMessage(ws, message) {
+        const conn = this.connMap.get(ws);
+        if (!conn)
+            return;
+        if (typeof message !== "string")
+            return;
+        const request = new Request(conn.url, {
+            headers: conn.headers,
+        });
+        await this.broker.handleMessage(conn, message, this.env, request);
+    }
+    webSocketClose(ws, code, reason) {
+        const conn = this.connMap.get(ws);
+        if (conn) {
+            this.broker.removeConnection(conn);
+            this.connMap.delete(ws);
+        }
+        try {
+            ws.close(code, reason);
+        }
+        catch {
+            // Ignore
+        }
+    }
+    webSocketError(ws) {
+        const conn = this.connMap.get(ws);
+        if (conn) {
+            this.broker.removeConnection(conn);
+            this.connMap.delete(ws);
+        }
+    }
+}

package/dist/server/handler.d.ts

@@ -0,0 +1,3 @@
+export declare function publishEvent(channel: string, action: "create" | "update" | "delete", key: string | undefined, data: any): Promise<void>;
+export declare function handleUpgrade(request: Request, platform: App.Platform | undefined): Promise<Response>;
+//# sourceMappingURL=handler.d.ts.map

package/dist/server/handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler.d.ts","sourceRoot":"","sources":["../../src/server/handler.ts"],"names":[],"mappings":"AAAA,wBAAsB,YAAY,CAChC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,QAAQ,GAAG,QAAQ,GAAG,QAAQ,EACtC,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,IAAI,EAAE,GAAG,iBAgCV;AAED,wBAAsB,aAAa,CACjC,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,GAAG,CAAC,QAAQ,GAAG,SAAS,GACjC,OAAO,CAAC,QAAQ,CAAC,CAqBnB"}

package/dist/server/handler.js

@@ -0,0 +1,51 @@
+export async function publishEvent(channel, action, key, data) {
+    const envId = "$app/environment";
+    let isDev = false;
+    try {
+        const env = await import(/* @vite-ignore */ envId);
+        isDev = env.dev;
+    }
+    catch { }
+    if (isDev) {
+        const { broadcastExternalChange } = await import("./dev-engine.js");
+        await broadcastExternalChange(channel, action, key, data);
+        return;
+    }
+    try {
+        const serverId = "$app/server";
+        const { getRequestEvent } = await import(/* @vite-ignore */ serverId);
+        const { platform } = getRequestEvent();
+        const namespace = platform?.env.SYNC_ENGINE;
+        if (!namespace)
+            return;
+        const id = namespace.idFromName("global");
+        const stub = namespace.get(id);
+        await stub.fetch("https://realtime.internal/broadcast", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ channel, action, key, data }),
+        });
+    }
+    catch (err) {
+        console.error("Failed to publish sync event to Durable Object:", err);
+    }
+}
+export async function handleUpgrade(request, platform) {
+    if (request.headers.get("Upgrade") !== "websocket") {
+        return new Response("Expected Upgrade: websocket", { status: 426 });
+    }
+    const namespace = platform?.env?.SYNC_ENGINE;
+    if (!namespace) {
+        return new Response("SyncEngine binding is not available", { status: 500 });
+    }
+    try {
+        const id = namespace.idFromName("global");
+        const stub = namespace.get(id);
+        return await stub.fetch(new Request("https://realtime.internal/websocket", request));
+    }
+    catch (err) {
+        return new Response(err.message || "SyncEngine binding is not available", {
+            status: 503,
+        });
+    }
+}

package/dist/server/index.d.ts

@@ -0,0 +1,25 @@
+import type { ZodSchema } from "zod";
+export type SyncContext = {
+    platform: App.Platform | undefined;
+    request: Request;
+    auth?: any;
+};
+export type SyncHandlerConfig<TRow = any> = {
+    channel: string | ((ctx: SyncContext) => string);
+    fetch: (ctx: SyncContext, since?: string) => Promise<TRow[]>;
+    create?: (ctx: SyncContext, data: TRow) => Promise<TRow>;
+    update?: (ctx: SyncContext, key: string, changes: Partial<TRow>) => Promise<TRow>;
+    delete?: (ctx: SyncContext, key: string) => Promise<void>;
+    authorize?: (ctx: SyncContext) => Promise<void>;
+    validate?: {
+        create?: ZodSchema<any>;
+        update?: ZodSchema<any>;
+    };
+    scope?: (ctx: SyncContext, action: "create" | "update" | "delete", data: any) => Promise<string[] | "all"> | string[] | "all";
+};
+export interface SyncHandler<TRow = any> {
+    config: SyncHandlerConfig<TRow>;
+    resolveChannel(ctx: SyncContext): string;
+}
+export declare function defineSync<TRow = any>(config: SyncHandlerConfig<TRow>): SyncHandler<TRow>;
+//# sourceMappingURL=index.d.ts.map

package/dist/server/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,KAAK,CAAC;AAErC,MAAM,MAAM,WAAW,GAAG;IACxB,QAAQ,EAAE,GAAG,CAAC,QAAQ,GAAG,SAAS,CAAC;IACnC,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,GAAG,CAAC;CACZ,CAAC;AAEF,MAAM,MAAM,iBAAiB,CAAC,IAAI,GAAG,GAAG,IAAI;IAC1C,OAAO,EAAE,MAAM,GAAG,CAAC,CAAC,GAAG,EAAE,WAAW,KAAK,MAAM,CAAC,CAAC;IACjD,KAAK,EAAE,CAAC,GAAG,EAAE,WAAW,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;IAC7D,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,WAAW,EAAE,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACzD,MAAM,CAAC,EAAE,CACP,GAAG,EAAE,WAAW,EAChB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,KACnB,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1D,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAChD,QAAQ,CAAC,EAAE;QACT,MAAM,CAAC,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC;QACxB,MAAM,CAAC,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC;KACzB,CAAC;IACF,KAAK,CAAC,EAAE,CACN,GAAG,EAAE,WAAW,EAChB,MAAM,EAAE,QAAQ,GAAG,QAAQ,GAAG,QAAQ,EACtC,IAAI,EAAE,GAAG,KACN,OAAO,CAAC,MAAM,EAAE,GAAG,KAAK,CAAC,GAAG,MAAM,EAAE,GAAG,KAAK,CAAC;CACnD,CAAC;AAEF,MAAM,WAAW,WAAW,CAAC,IAAI,GAAG,GAAG;IACrC,MAAM,EAAE,iBAAiB,CAAC,IAAI,CAAC,CAAC;IAChC,cAAc,CAAC,GAAG,EAAE,WAAW,GAAG,MAAM,CAAC;CAC1C;AAED,wBAAgB,UAAU,CAAC,IAAI,GAAG,GAAG,EACnC,MAAM,EAAE,iBAAiB,CAAC,IAAI,CAAC,GAC9B,WAAW,CAAC,IAAI,CAAC,CASnB"}

package/dist/server/index.js

@@ -0,0 +1,10 @@
+export function defineSync(config) {
+    return {
+        config,
+        resolveChannel(ctx) {
+            return typeof config.channel === "function"
+                ? config.channel(ctx)
+                : config.channel;
+        },
+    };
+}

package/dist/vite.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from "vite";
+export type SyncDevPluginOptions = {
+    handlersPath?: string;
+};
+export declare function syncDevPlugin(options?: SyncDevPluginOptions): Plugin;
+//# sourceMappingURL=vite.d.ts.map

package/dist/vite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite.d.ts","sourceRoot":"","sources":["../src/vite.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAanC,MAAM,MAAM,oBAAoB,GAAG;IACjC,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,wBAAgB,aAAa,CAAC,OAAO,CAAC,EAAE,oBAAoB,GAAG,MAAM,CA4EpE"}

package/dist/vite.js

@@ -0,0 +1,55 @@
+const SYNC_PATH = "/api/sync";
+export function syncDevPlugin(options) {
+    const handlersPath = options?.handlersPath ?? "/src/lib/server/sync-handlers.ts";
+    return {
+        name: "sync-dev-websocket",
+        apply: "serve",
+        async configureServer(server) {
+            // Dynamic import — ws is a transitive dependency of Vite itself.
+            // @ts-expect-error -- ws has no bundled type declarations
+            const { WebSocketServer } = (await import("ws"));
+            const wss = new WebSocketServer({ noServer: true });
+            server.httpServer?.on("upgrade", (request, socket, head) => {
+                const url = new URL(request.url ?? "", `http://${request.headers.host}`);
+                if (url.pathname !== SYNC_PATH) {
+                    return;
+                }
+                wss.handleUpgrade(request, socket, head, (client) => {
+                    console.log("sync-dev-plugin: WebSocket upgrade handler starting (buffering messages)...");
+                    // Buffer messages while async ssrLoadModule runs to avoid race conditions
+                    const messageQueue = [];
+                    const onMessage = (data) => {
+                        messageQueue.push(data);
+                    };
+                    client.on("message", onMessage);
+                    (async () => {
+                        try {
+                            // Load the handlers module dynamically from the user-configured path
+                            const handlersModule = await server.ssrLoadModule(handlersPath);
+                            const devEngine = await server.ssrLoadModule("@sveltebase/sync/server/dev-engine");
+                            // Register handlers dynamically before connecting client
+                            devEngine.setHandlers(handlersModule.handlers);
+                            // Remove temporary buffering listener
+                            client.off("message", onMessage);
+                            // Register client in the dev engine
+                            devEngine.addClient(client, request);
+                            console.log("sync-dev-plugin: WebSocket upgrade handler completed, replaying buffered messages:", messageQueue.length);
+                            // Replay any buffered messages
+                            for (const msg of messageQueue) {
+                                client.emit("message", msg);
+                            }
+                        }
+                        catch (err) {
+                            console.error("sync-dev-plugin: Error in WebSocket upgrade handler:", err);
+                            try {
+                                client.off("message", onMessage);
+                                client.close(1011, "Internal server error");
+                            }
+                            catch { }
+                        }
+                    })();
+                });
+            });
+        },
+    };
+}