vzcode 2.2.0 → 2.3.0

package/dist/server/generateAIResponse.js

@@ -0,0 +1,129 @@
+import OpenAI from 'openai';
+import { json1Presence } from '../ot.js';
+// This module implements the generation of the AI response,
+// using the OpenAI client.
+// These environment variables are used to configure the OpenAI client.
+// See `.env.sample` for the expected values.
+const { VZCODE_AI_API_KEY, VZCODE_AI_BASE_URL } = process.env;
+// If neither of these are not set, the OpenAI client will not be initialized,
+// e.g. for local development where no AI is needed.
+const isAIEnabled = VZCODE_AI_API_KEY !== undefined &&
+    VZCODE_AI_BASE_URL !== undefined;
+const { editOp, type } = json1Presence;
+// Debug flag to log more information during development.
+const debug = false;
+// Feature flag to slow down AI for development/testing.
+// Particularly relevant for debugging ShareDB and CodeMirror sync issues.
+// This allows you to test the case of editing the document at the
+// same time as the AI generation is happening.
+const slowdown = false;
+// The options passed into the OpenAI client
+// new OpenAI(openAIOptions)
+const openAIOptions = {};
+// Support specifying the API key via an environment variable
+// If VZCODE_AI_API_KEY is not set, note that the OpenAI client
+// will look for the OPENAI_API_KEY environment variable instead.
+if (process.env.VZCODE_AI_API_KEY !== undefined) {
+    openAIOptions.apiKey = process.env.VZCODE_AI_API_KEY;
+}
+// Support for local AI server
+if (process.env.VZCODE_AI_BASE_URL !== undefined) {
+    // The OpenAI client errors if the API key is not set,
+    // so in the case where we don't need an API key,
+    // e.g. for testing with a local AI server like LM Studio or LocalAI,
+    // we populate the option with a fake API key, so it doesn't error.
+    if (!openAIOptions.apiKey) {
+        openAIOptions.apiKey = 'Fake API Key';
+    }
+    openAIOptions.baseURL = process.env.VZCODE_AI_BASE_URL;
+}
+debug &&
+    console.log('openAIOptions: ' +
+        JSON.stringify(openAIOptions, null, 2));
+let openai;
+if (isAIEnabled) {
+    openai = new OpenAI(openAIOptions);
+}
+// The name of the source that the AI responses
+// will be attributed to in ShareDB operations.
+const AIShareDBSourceName = 'AIAssist';
+// Returns trie if the operation comes from AI.
+const opComesFromAIAssist = (ops, source) => source === AIShareDBSourceName;
+// Keeps track of the currently ongoing AI streams.
+// There could be many streams at the same time.
+export const streams = {};
+export const generateAIResponse = async ({ inputText, insertionCursor, fileId, streamId, shareDBDoc, }) => {
+    if (!isAIEnabled) {
+        console.log('[generateAIResponse] AI is not enabled. Skipping AI generation.');
+        console.log('[generateAIResponse] To enable AI, see .env.sample for the required environment variables.');
+        return;
+    }
+    if (debug) {
+        console.log('[generateAIResponse] inputText:', inputText);
+        console.log('[generateAIResponse] insertionCursor:', insertionCursor);
+        console.log('[generateAIResponse] fileId:', fileId);
+        console.log('[generateAIResponse] streamId:', streamId);
+        console.log('[generateAIResponse] shareDBDoc:', shareDBDoc);
+    }
+    // Handle the case that a user edits the text in the document
+    // that comes becofore the insertion cursor.
+    const accomodateDocChanges = (op, source) => {
+        if (!opComesFromAIAssist(op, source)) {
+            if (op !== null) {
+                insertionCursor = type
+                    .transformPosition(['files', fileId, 'text', insertionCursor], op)
+                    .slice(-1)[0];
+            }
+        }
+    };
+    shareDBDoc.on('op', accomodateDocChanges);
+    // The prompt!
+    const messages = [
+        {
+            role: 'system',
+            content: [
+                'You are an expert programmer.',
+                'Your task is to output ONLY the code that replaces <FILL_ME> correctly.',
+                'Do not add any markdown around.',
+                'Do not duplicate the code before or after <FILL_ME>.',
+                'Do not make any changes outside of <FILL_ME>.',
+                'Do not enclose the output with backticks.',
+                'If any additional instructions are required, they will be provided in comments.',
+            ].join(' '),
+        },
+        { role: 'user', content: inputText },
+    ];
+    if (debug) {
+        console.log('[generateAIResponse] messages:');
+        console.log(JSON.stringify(messages, null, 2));
+    }
+    streams[streamId] = await openai.chat.completions.create({
+        // model: 'gpt-3.5-turbo',
+        model: 'gpt-4o',
+        messages,
+        reasoning: {
+            effort: 'medium',
+            exclude: false,
+        }, // Type assertion for OpenRouter-specific reasoning parameter
+        provider: {
+            sort: 'throughput',
+        }, // Type assertion for OpenRouter-specific provider parameter
+        stream: true,
+    });
+    for await (const part of streams[streamId]) {
+        const op = editOp(['files', fileId, 'text'], 'text-unicode', [
+            insertionCursor,
+            part.choices[0]?.delta?.content || '',
+        ]);
+        shareDBDoc.submitOp(op, {
+            source: AIShareDBSourceName,
+        });
+        if (slowdown) {
+            await new Promise((resolve) => {
+                setTimeout(resolve, 2000);
+            });
+        }
+        insertionCursor += (part.choices[0]?.delta?.content || '').length;
+    }
+    shareDBDoc.off('op', accomodateDocChanges);
+};

package/dist/server/handleAIAssist.js

@@ -0,0 +1,39 @@
+import { generateAIResponse, streams, } from './generateAIResponse.js';
+const debug = false;
+export const handleAIAssist = (shareDBDoc) => async (req, res) => {
+    const { inputText, insertionCursor, fileId } = req.body;
+    if (debug) {
+        console.log('[handleAIAssist] inputText:', inputText);
+        console.log('[handleAIAssist] insertionCursor:', insertionCursor);
+        console.log('[handleAIAssist] fileId:', fileId);
+    }
+    try {
+        // Generate a unique streamId for this request
+        const streamId = `stream_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        await generateAIResponse({
+            inputText,
+            insertionCursor,
+            fileId,
+            streamId,
+            shareDBDoc,
+        });
+        res
+            .status(200)
+            .send({ message: 'Operation successful!' });
+    }
+    catch (error) {
+        console.error('handleAIAssist error:', error);
+        res.status(500).send({
+            message: 'Internal Server Error',
+            error: error.message,
+        });
+    }
+};
+export function haltGeneration(streamId) {
+    const stream = streams[streamId];
+    // Stream can be undefined here if the user
+    // clicks start and stop very quickly.
+    if (stream) {
+        stream.controller.abort();
+    }
+}

package/dist/server/handleAICopilot.js

@@ -0,0 +1,81 @@
+import { ChatOpenAI } from '@langchain/openai';
+import { StringOutputParser } from '@langchain/core/output_parsers';
+// This module implements the generation of the copilot response.
+// Debug flag to log more information during development.
+const debug = false;
+export const handleAICopilot = () => {
+    // These environment variables are used to configure the OpenAI client.
+    // See `.env.sample` for the expected values.
+    const { VZCODE_AI_COPILOT_API_KEY, VZCODE_AI_COPILOT_BASE_URL, VZCODE_AI_COPILOT_MODEL, } = process.env;
+    // If neither of these are not set, the OpenAI client will not be initialized,
+    // e.g. for local development where no AI is needed.
+    const isCopilotEnabled = VZCODE_AI_COPILOT_API_KEY !== undefined &&
+        VZCODE_AI_COPILOT_BASE_URL !== undefined &&
+        VZCODE_AI_COPILOT_MODEL !== undefined;
+    debug &&
+        console.log('isCopilotEnabled: ' + isCopilotEnabled);
+    debug &&
+        console.log({
+            VZCODE_AI_COPILOT_API_KEY,
+            VZCODE_AI_COPILOT_BASE_URL,
+            VZCODE_AI_COPILOT_MODEL,
+        });
+    let chatModel;
+    if (isCopilotEnabled) {
+        const options = {
+            modelName: VZCODE_AI_COPILOT_MODEL,
+            configuration: {
+                apiKey: VZCODE_AI_COPILOT_API_KEY,
+                baseURL: VZCODE_AI_COPILOT_BASE_URL,
+            },
+            additionalParameters: {
+                provider: { sort: 'throughput' },
+            },
+            streaming: false,
+        };
+        debug && console.log('chatModel options:', options);
+        chatModel = new ChatOpenAI(options);
+    }
+    return async (req, res) => {
+        // Don't break if the AI is not enabled.
+        // This is useful for local development.
+        if (!isCopilotEnabled) {
+            res.status(200).send({ text: '' });
+            return;
+        }
+        const { prefix, suffix } = req.body;
+        const messages = [
+            {
+                role: 'user',
+                content: [
+                    'Complete the missing part of the text below:\n\n',
+                    '\`\`\`\n',
+                    prefix,
+                    '<MISSING_PART>',
+                    suffix,
+                    '\`\`\`\n\n',
+                    'ONLY output the text that replaces <MISSING_PART>.\n\n',
+                    'NEVER include \`\`\`javascript or similar code blocks.\n\n',
+                ].join(''),
+            },
+        ];
+        if (debug) {
+            console.log('[generateAIResponse] prompt:\n```\n' +
+                messages[0].content +
+                '\n```\n');
+        }
+        try {
+            const result = await chatModel.invoke(messages);
+            const parser = new StringOutputParser();
+            const text = await parser.invoke(result);
+            res.status(200).send({ text });
+        }
+        catch (error) {
+            console.error('handleAICopilot error:', error);
+            res.status(500).send({
+                message: 'Internal Server Error',
+                error: error.message,
+            });
+        }
+    };
+};

package/dist/server/index.js

@@ -0,0 +1,297 @@
+#!/usr/bin/env node
+import WebSocketJSONStream from '@teamwork/websocket-json-stream';
+import bodyParser from 'body-parser';
+import express from 'express';
+import fs from 'fs';
+import http from 'http';
+import open from 'open';
+import path from 'path';
+import ShareDB from 'sharedb';
+import { fileURLToPath } from 'url';
+import { WebSocketServer } from 'ws';
+import { json1Presence } from '../ot.js';
+import { computeInitialDocument } from './computeInitialDocument.js';
+import { handleAIAssist } from './handleAIAssist.js';
+import { handleAICopilot } from './handleAICopilot.js';
+import { handleAIChatMessage } from './handleAIChatMessage.js';
+import { isDirectory } from './isDirectory.js';
+import { createToken } from './livekit.js';
+import './setupEnv.js';
+// Import the image file utility
+const isImageFile = (fileName) => {
+    return (fileName.match(/\.(png|jpg|jpeg|gif|bmp|svg|webp)$/i) !== null);
+};
+// The time in milliseconds by which auto-saving is debounced.
+const autoSaveDebounceTimeMS = 800;
+// The time in milliseconds by which auto-saving is throttled
+// when the user is interacting with the widgets in the editor.
+const throttleTimeMS = 100;
+// Helper function to get the port from command line arguments or use default.
+function getPortFromArgs(defaultPort = 3030) {
+    const portArg = process.argv.find((arg) => arg.startsWith('--port='));
+    if (portArg) {
+        return parseInt(portArg.split('=')[1], 10);
+    }
+    return defaultPort;
+}
+// Server port.
+const port = getPortFromArgs();
+const initialDocument = computeInitialDocument({
+    // Use the current working directory to look for files.
+    fullPath: process.cwd(),
+});
+// Register our custom OT type,
+// because it does not ship with ShareDB.
+ShareDB.types.register(json1Presence.type);
+const app = express();
+// Use ShareDB over WebSocket
+const shareDBBackend = new ShareDB({
+    // Enable presence
+    // See https://github.com/share/sharedb/blob/master/examples/rich-text-presence/server.js#L9
+    presence: true,
+    doNotForwardSendPresenceErrorsToClient: true,
+});
+const server = http.createServer(app);
+const wss = new WebSocketServer({ server });
+wss.on('connection', (ws) => {
+    const clientStream = new WebSocketJSONStream(ws);
+    shareDBBackend.listen(clientStream);
+    // Prevent server crashes on errors.
+    clientStream.on('error', (error) => {
+        console.log('clientStream error: ' + error.message);
+    });
+    // Handle errors
+    ws.on('error', (error) => {
+        console.log('ws error: ' + error.message);
+    });
+    // Handle disconnections
+    ws.on('close', () => {
+        clientStream.end();
+    });
+});
+// Serve static files
+const filename = fileURLToPath(import.meta.url);
+const dirname = path.dirname(filename);
+const dir = path.join(dirname, '..', '..', 'dist');
+app.use(express.static(dir));
+// Create the initial "document",
+// which is a representation of files on disk.
+const shareDBConnection = shareDBBackend.connect();
+const shareDBDoc = shareDBConnection.get('documents', '1');
+// Set up presence for AI editing following the same pattern as useShareDB.ts
+const docPresence = shareDBConnection.getDocPresence('documents', '1');
+// Create local presence for AI editing with a unique ID
+const generateAIEditId = () => {
+    const timestamp = Date.now().toString(36);
+    return `ai-edit-${timestamp}`;
+};
+const createAIEditLocalPresence = () => docPresence.create(generateAIEditId());
+shareDBDoc.create(initialDocument, json1Presence.type.uri);
+// Handle AI Assist requests.
+app.post('/ai-assist', bodyParser.json(), handleAIAssist(shareDBDoc));
+// Handle AI Copilot requests.
+app.post('/ai-copilot', bodyParser.json(), handleAICopilot());
+// Handle AI Chat Message requests.
+app.post('/ai-chat-message', bodyParser.json(), handleAIChatMessage({
+    shareDBDoc,
+    createAIEditLocalPresence,
+    onCreditDeduction: undefined,
+}));
+// Livekit Token Generator
+app.get('/livekit-token', async (req, res) => {
+    const { room, username } = req.query;
+    res.send(await createToken(room, username));
+});
+// The state of the document when files were last auto-saved.
+let previousDocument = initialDocument;
+// Saves the files that changed.
+const save = () => {
+    const currentDocument = shareDBDoc.data;
+    // Take a look at each file (key) previously and currently.
+    const allKeys = Object.keys({
+        ...currentDocument.files,
+        ...previousDocument.files,
+    });
+    const directoriesToDelete = [];
+    for (const key of allKeys) {
+        const previous = previousDocument.files[key];
+        const current = currentDocument.files[key];
+        // If this file was neither created nor deleted...
+        if (previous && current) {
+            // Handle changing of text content.
+            if (previous.text !== current.text) {
+                if (isImageFile(current.name)) {
+                    // Write image files as binary from base64
+                    const buffer = Buffer.from(current.text, 'base64');
+                    fs.writeFileSync(current.name, buffer);
+                }
+                else {
+                    // Write non-image files as text
+                    fs.writeFileSync(current.name, current.text);
+                }
+            }
+            // // Handle renaming files.
+            // if (previous.name !== current.name) {
+            //   const previousPath = previous.name.split('/');
+            //   const currentPath = current.name.split('/');
+            //   // - If the path is length 1 for previous and current,
+            //   //   then this should be true.
+            //   // - If the path length is the sane for previous and current,
+            //   //   AND all the entries leading up to the last one are the same
+            //   //   between previous and current, AND the last entry in the arrays
+            //   //   (the file name itself) is different between previous and current
+            //   const onlyFileNameChanged =
+            //     (previousPath.length === 1 &&
+            //       currentPath.length === 1) ||
+            //     (previousPath.length === currentPath.length &&
+            //       previousPath
+            //         .slice(0, -1)
+            //         .every(
+            //           (val, index) => val === currentPath[index],
+            //         ) &&
+            //       previousPath.at(-1) !== currentPath.at(-1));
+            //   // This logic works if only the file name itself changes.
+            //   if (onlyFileNameChanged) {
+            //     fs.renameSync(previous.name, current.name);
+            //   }
+            //   {
+            //     // If we get here, then the directory may have been renamed,
+            //     // or the file has been moved between directories.
+            //     // If we get here, then the directory may have been renamed,
+            //     // or the file has been moved between directories.
+            //     const newDir = path.dirname(current.name);
+            //     // Check if the new directory exists, if not, create it
+            //     if (!fs.existsSync(newDir)) {
+            //       fs.mkdirSync(newDir, { recursive: true });
+            //     }
+            //     // Move the file to the new directory
+            //     fs.renameSync(previous.name, current.name);
+            //   }
+            // }
+            // Handle renaming files.
+            if (previous.name !== current.name) {
+                if (isDirectory(previous.name)) {
+                    // If the directory itself is being renamed,
+                    // Phase I: Ignore it, and get the files moved
+                    // Phase II: Keep track of these, and delete them after
+                    //           all the files moved.
+                    // directoriesToDelete.push(previous.name)
+                    directoriesToDelete.push(previous.name);
+                }
+                else {
+                    const newDir = path.dirname(current.name);
+                    // Check if the new directory exists, if not, create it
+                    if (!fs.existsSync(newDir)) {
+                        fs.mkdirSync(newDir, { recursive: true });
+                    }
+                    // Move the file to the new directory
+                    fs.renameSync(previous.name, current.name);
+                }
+            }
+        }
+        // handle deleting files and directories.
+        if (previous && !current) {
+            let stats = fs.statSync(previous.name);
+            //Check if the file path we are trying to delete is a directory
+            if (!stats.isDirectory()) {
+                fs.unlinkSync(previous.name);
+            }
+            else {
+                //Performs directory deletion.
+                fs.rm(previous.name, {
+                    recursive: true, //Makes sure that all files in directory are deleted.
+                }, (error) => {
+                    if (error) {
+                        console.log(error);
+                    }
+                });
+            }
+        }
+        // Handle creating files and Directories.
+        if (!previous && current) {
+            //File Creation
+            if (!isDirectory(current.name)) {
+                if (isImageFile(current.name)) {
+                    // Write image files as binary from base64
+                    const buffer = Buffer.from(current.text, 'base64');
+                    fs.writeFileSync(current.name, buffer);
+                }
+                else {
+                    // Write non-image files as text
+                    fs.writeFileSync(current.name, current.text);
+                }
+            }
+            else {
+                fs.mkdirSync(current.name, { recursive: true });
+            }
+        }
+    }
+    // TODO deleted all directories under directoriesToDelete
+    for (const dir of directoriesToDelete) {
+        //Performs directory deletion.
+        fs.rm(dir, {
+            recursive: true, //Makes sure that all files in directory are deleted.
+        }, (error) => {
+            if (error) {
+                console.log(error);
+            }
+        });
+    }
+    previousDocument = currentDocument;
+};
+// // Listen for when users modify files.
+// // Files get written to disk after `autoSaveDebounceTimeMS`
+// // milliseconds of inactivity.
+// let timeout;
+// shareDBDoc.subscribe(() => {
+//   shareDBDoc.on('op', () => {
+//     // console.log(shareDBDoc.data.isInteracting);
+//     clearTimeout(timeout);
+//     timeout = setTimeout(save, autoSaveDebounceTimeMS);
+//   });
+// });
+let lastExecutedTime = Date.now();
+let lastChangeTimeout; // This timeout ensures the last change is saved
+// Function to throttle the saving
+function throttleSave() {
+    const now = Date.now();
+    const timeSinceLastExecution = now - lastExecutedTime;
+    if (timeSinceLastExecution > throttleTimeMS) {
+        save();
+        lastExecutedTime = now;
+    }
+    else {
+        // Clear the previous timeout and set a new one to save the last change
+        clearTimeout(lastChangeTimeout);
+        lastChangeTimeout = setTimeout(() => {
+            save();
+            lastExecutedTime = now;
+        }, throttleTimeMS - timeSinceLastExecution);
+    }
+}
+// Function to debounce the saving
+let debounceTimeout;
+function debounceSave() {
+    clearTimeout(debounceTimeout);
+    debounceTimeout = setTimeout(save, autoSaveDebounceTimeMS);
+}
+// Subscribe to listen for modifications
+shareDBDoc.subscribe(() => {
+    shareDBDoc.on('op', () => {
+        if (shareDBDoc.data.isInteracting) {
+            throttleSave();
+        }
+        else {
+            debounceSave();
+        }
+    });
+});
+server.listen(port, async () => {
+    // Note: ngrok support can be added when the package is properly installed
+    // Sets the port to the one specified in the environment
+    // variable (for development) or the default port.
+    let livePort = process.env.EDITOR_PORT || port;
+    console.log(`EDITOR_PORT: ${process.env.EDITOR_PORT}`);
+    console.log(`Editor is live at http://localhost:${livePort}`);
+    open(`http://localhost:${livePort}`);
+});

package/dist/server/livekit.js

@@ -0,0 +1,17 @@
+import { AccessToken } from 'livekit-server-sdk';
+const { LIVEKIT_API_KEY, LIVEKIT_API_SECRET } = process.env;
+export const createToken = async (roomName, username) => {
+    // If this room doesn't exist, it'll be automatically created when the first
+    // client joins
+    // Identifier to be used for participant.
+    // It's available as LocalParticipant.identity with livekit-client SDK
+    // console.log(username);
+    const participantName = `${username}`;
+    const at = new AccessToken(LIVEKIT_API_KEY, LIVEKIT_API_SECRET, {
+        identity: participantName,
+        // Token to expire after 10 minutes
+        ttl: '10m',
+    });
+    at.addGrant({ roomJoin: true, room: roomName });
+    return await at.toJwt();
+};

package/dist/server/prettier.js

@@ -0,0 +1,90 @@
+import { format } from 'prettier/standalone';
+import * as prettierPluginBabel from 'prettier/plugins/babel';
+import * as prettierPluginEstree from 'prettier/plugins/estree';
+import * as prettierPluginHtml from 'prettier/plugins/html';
+import * as prettierPluginMarkdown from 'prettier/plugins/markdown';
+import * as prettierPluginCSS from 'prettier/plugins/postcss';
+import * as prettierPluginTypescript from 'prettier/plugins/typescript';
+// Parser mappings - matches client-side implementation
+const parsers = {
+    js: 'babel',
+    jsx: 'babel',
+    mjs: 'babel',
+    cjs: 'babel',
+    ts: 'typescript',
+    tsx: 'typescript',
+    css: 'css',
+    html: 'html',
+    json: 'json',
+    json5: 'json5',
+    md: 'markdown',
+    markdown: 'markdown',
+};
+// Prettier plugins - matches client-side implementation
+const plugins = [
+    prettierPluginBabel,
+    prettierPluginEstree,
+    prettierPluginHtml,
+    prettierPluginMarkdown,
+    prettierPluginTypescript,
+    prettierPluginCSS,
+];
+// Prettier options - matches client-side implementation and .prettierrc
+const prettierOptions = {
+    proseWrap: 'always',
+    singleQuote: true,
+    printWidth: 60,
+};
+/**
+ * Extracts file extension from filename
+ * Example: 'foo.js' => 'js'
+ */
+const getFileExtension = (fileName) => {
+    const match = fileName.match(/\.([^.]+)$/);
+    return match ? match[1] : '';
+};
+/**
+ * Formats a single file using Prettier
+ */
+export const formatFile = async (fileText, fileName) => {
+    const fileExtension = getFileExtension(fileName);
+    const parser = parsers[fileExtension];
+    // If no parser is found, return null (no formatting)
+    if (!parser) {
+        return null;
+    }
+    try {
+        const formatted = await format(fileText, {
+            parser,
+            plugins,
+            ...prettierOptions,
+        });
+        return formatted;
+    }
+    catch (error) {
+        // Log error but don't throw - return original text
+        console.error(`Prettier formatting error for ${fileName}:`, error);
+        return null;
+    }
+};
+/**
+ * Formats multiple files using Prettier
+ * Only formats files that have supported extensions
+ * Returns a map of fileId -> formatted text for successfully formatted files
+ */
+export const formatFiles = async (files, fileIds) => {
+    const results = {};
+    const targetFileIds = fileIds || Object.keys(files);
+    // Process files in parallel for better performance
+    const formatPromises = targetFileIds.map(async (fileId) => {
+        const file = files[fileId];
+        if (!file)
+            return;
+        const formatted = await formatFile(file.text, file.name);
+        if (formatted !== null && formatted !== file.text) {
+            results[fileId] = formatted;
+        }
+    });
+    await Promise.all(formatPromises);
+    return results;
+};

package/{src/server/setupEnv.ts → dist/server/setupEnv.js}

@@ -1,8 +1,7 @@
 import dotenv from 'dotenv';
 import { fileURLToPath } from 'url';
 import { join } from 'node:path';
-
 const dir = fileURLToPath(import.meta.url);
 dotenv.config({
-  path: join(dir, '../../../.env'),
+    path: join(dir, '../../../.env'),
 });

package/dist/submitOperation.js

@@ -0,0 +1,14 @@
+import { diff } from './ot.js';
+/**
+ * Creates a submitOperation function that can be used to submit diff-based operations to ShareDB.
+ * This is the core logic extracted from useSubmitOperation for reuse across client and server.
+ */
+export const createSubmitOperation = (shareDBDoc) => {
+    return (next) => {
+        const data = shareDBDoc.data;
+        const op = diff(data, next(data));
+        if (op && shareDBDoc) {
+            shareDBDoc.submitOp(op);
+        }
+    };
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};