@el-j/google-sheet-translations 3.0.0-beta.3 → 3.0.0-beta.5

package/dist/esm/index.js

@@ -10,6 +10,7 @@ import { Readable } from "node:stream";
 import fs$1 from "node:fs/promises";
 import { parse } from "csv-parse/sync";
 import crypto from "node:crypto";
+import nacl from "tweetnacl";
 //#region src/utils/validateEnv.ts
 /**
 * Validates that Google service-account credentials are present.
@@ -264,6 +265,10 @@ const COMMON_LOCALE_PATTERNS = [
 	/^[a-z]{2}-[a-z]{2}-[a-z]+$/
 ];
 const NON_LOCALE_KEYWORDS = [
+	"var",
+	"vars",
+	"variable",
+	"variables",
 	"key",
 	"keys",
 	"id",
@@ -3260,6 +3265,749 @@ function createCryptPadCsvInputProvider(options, depsOverrides = {}) {
 	};
 }
 //#endregion
+//#region src/providers/cryptpad/crypto.ts
+/** Decodes CryptPad base64 string (which may have '-' instead of '/' and no padding). */
+function b64Decode(str) {
+	let s = str.replace(/-/g, "/");
+	const pad = s.length % 4;
+	if (pad) s += "=".repeat(4 - pad);
+	return new Uint8Array(Buffer.from(s, "base64"));
+}
+/** Encodes bytes to standard base64 string. */
+function b64Encode(bytes) {
+	return Buffer.from(bytes).toString("base64");
+}
+/** Decodes UTF-8 string to Uint8Array. */
+function decodeUTF8(str) {
+	return new Uint8Array(Buffer.from(str, "utf8"));
+}
+/** Encodes Uint8Array to UTF-8 string. */
+function encodeUTF8(bytes) {
+	return Buffer.from(bytes).toString("utf8");
+}
+/**
+* Parses a CryptPad URL and extracts the app type, mode, seed, and whether it requires a password.
+* Format: https://{host}/{app}/#/{version}/{app}/{mode}/{seed}[/p/]
+*/
+function parsePadUrl(url) {
+	let urlObj;
+	try {
+		urlObj = new URL(url);
+	} catch {
+		throw new Error(`Invalid CryptPad URL: "${url}"`);
+	}
+	const match = urlObj.hash.match(/#\/(\d+)\/([^/]+)\/([^/]+)\/([^/]+)(\/p\/)?/);
+	if (!match) throw new Error(`Unsupported CryptPad URL format: "${url}". Expected "#/<version>/<app>/<mode>/<seed>[/p/]"`);
+	const [, versionStr, app, modeRaw, seed, passwordFlag] = match;
+	const mode = modeRaw === "edit" ? "edit" : "view";
+	const isPasswordProtected = Boolean(passwordFlag);
+	return {
+		origin: urlObj.origin,
+		version: parseInt(versionStr, 10),
+		app,
+		mode,
+		seed,
+		isPasswordProtected,
+		cleanUrl: `${urlObj.origin}/${app}/#/${versionStr}/${app}/${mode}/${seed}${isPasswordProtected ? "/p/" : ""}`
+	};
+}
+/**
+* Derives the Netflux channel ID (hex string) and symmetric encryption key (32 bytes)
+* from a CryptPad pad seed and optional password according to CryptPad's createEditCryptor2 / createViewCryptor2 protocol.
+*/
+function deriveCryptPadKeys(seedStr, password) {
+	const seed = b64Decode(seedStr);
+	if (!password) {
+		const seed2 = crypto.createHash("sha512").update(seed).digest().subarray(32, 64);
+		const hash2 = crypto.createHash("sha512").update(seed2).digest();
+		return {
+			channelHex: hash2.subarray(0, 16).toString("hex"),
+			cryptKey: new Uint8Array(hash2.subarray(16, 48))
+		};
+	}
+	const pwBytes = decodeUTF8(password);
+	const superSeed1 = Buffer.concat([Buffer.from(pwBytes), Buffer.from(seed)]);
+	const seed2 = crypto.createHash("sha512").update(superSeed1).digest().subarray(32, 64);
+	const superSeed2 = Buffer.concat([Buffer.from(pwBytes), Buffer.from(seed2)]);
+	const hash2 = crypto.createHash("sha512").update(superSeed2).digest();
+	return {
+		channelHex: hash2.subarray(0, 16).toString("hex"),
+		cryptKey: new Uint8Array(hash2.subarray(16, 48))
+	};
+}
+/**
+* Decrypts an encrypted CryptPad message payload formatted as `nonce|ciphertext`
+* (or optionally prefixed with a 64-byte Ed25519 signature from historyKeeper).
+*/
+function decryptCryptPadPayload(payload, cryptKey) {
+	if (!payload || typeof payload !== "string") return null;
+	const candidates = [];
+	if (payload.includes("|")) candidates.push(payload);
+	const rawBytes = b64Decode(payload);
+	if (rawBytes.length > 64) {
+		const strWithoutSig = encodeUTF8(rawBytes.subarray(64));
+		if (strWithoutSig.includes("|")) candidates.push(strWithoutSig);
+	}
+	for (const cand of candidates) {
+		const parts = cand.split("|");
+		if (parts.length === 2) try {
+			const nonce = b64Decode(parts[0]);
+			const cipher = b64Decode(parts[1]);
+			if (nonce.length === 24) {
+				const opened = nacl.secretbox.open(cipher, nonce, cryptKey);
+				if (opened) return encodeUTF8(opened);
+			}
+		} catch {}
+	}
+	return null;
+}
+/**
+* Encrypts a plaintext message payload using TweetNaCl secretbox (XSalsa20-Poly1305).
+* Formats output as `base64(nonce)|base64(ciphertext)`.
+*/
+function encryptCryptPadPayload(plaintext, cryptKey) {
+	const nonce = nacl.randomBytes(24);
+	const msgBytes = decodeUTF8(plaintext);
+	const cipher = nacl.secretbox(msgBytes, nonce, cryptKey);
+	return `${b64Encode(nonce)}|${b64Encode(cipher)}`;
+}
+//#endregion
+//#region src/providers/cryptpad/netflux.ts
+/**
+* Discovers the real WebSocket URL for a CryptPad instance by querying its `/api/config` endpoint.
+*/
+async function resolveCryptPadWebsocketUrl(origin, signal) {
+	try {
+		const configUrl = `${origin.replace(/\/$/, "")}/api/config`;
+		const res = await fetch(configUrl, { signal });
+		if (res.ok) {
+			const match = (await res.text()).match(/"websocketPath":\s*"([^"]+)"/);
+			if (match && match[1]) return match[1];
+		}
+	} catch {}
+	const urlObj = new URL(origin);
+	return `${urlObj.protocol === "https:" ? "wss:" : "ws:"}//${urlObj.host}/cryptpad_websocket`;
+}
+/**
+* Connects to the CryptPad Netflux WebSocket server, joins a channel,
+* requests its complete history from the historyKeeper peer, decrypts all messages,
+* and returns the decrypted message strings.
+*/
+function fetchChannelHistory(wsUrl, channelHex, cryptKey, options = {}) {
+	const { timeoutMs = 8e3, quietPeriodMs = 1200, signal } = options;
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) return reject(/* @__PURE__ */ new Error("Operation aborted"));
+		const ws = new WebSocket(wsUrl);
+		let seq = 1;
+		const decryptedMessages = [];
+		let quietTimer = null;
+		let overallTimeout = null;
+		let requestedHistory = false;
+		const cleanup = () => {
+			if (quietTimer) clearTimeout(quietTimer);
+			if (overallTimeout) clearTimeout(overallTimeout);
+			try {
+				ws.close();
+			} catch {}
+		};
+		const finish = () => {
+			cleanup();
+			resolve(decryptedMessages);
+		};
+		const resetQuietTimer = () => {
+			if (quietTimer) clearTimeout(quietTimer);
+			quietTimer = setTimeout(finish, quietPeriodMs);
+		};
+		overallTimeout = setTimeout(() => {
+			cleanup();
+			if (decryptedMessages.length > 0) resolve(decryptedMessages);
+			else reject(/* @__PURE__ */ new Error(`Timeout after ${timeoutMs}ms waiting for CryptPad channel "${channelHex}" history.`));
+		}, timeoutMs);
+		if (signal) signal.addEventListener("abort", () => {
+			cleanup();
+			reject(/* @__PURE__ */ new Error("Operation aborted"));
+		});
+		ws.onopen = () => {
+			ws.send(JSON.stringify([
+				seq++,
+				"JOIN",
+				channelHex
+			]));
+		};
+		ws.onmessage = (event) => {
+			try {
+				const raw = typeof event.data === "string" ? event.data : event.data.toString();
+				const msg = JSON.parse(raw);
+				if (!Array.isArray(msg)) return;
+				const [, peerId, cmd, , payload] = msg;
+				if (cmd === "JOIN" && typeof peerId === "string" && peerId.length === 16) {
+					if (!requestedHistory) {
+						requestedHistory = true;
+						ws.send(JSON.stringify([
+							seq++,
+							"MSG",
+							peerId,
+							JSON.stringify([
+								"GET_HISTORY",
+								channelHex,
+								{}
+							])
+						]));
+						resetQuietTimer();
+					}
+				}
+				if (cmd === "MSG") {
+					let encStr = payload;
+					if (!encStr && typeof msg[3] === "string" && msg[3].length > 50) encStr = msg[3];
+					try {
+						const parsed = JSON.parse(encStr);
+						if (Array.isArray(parsed) && parsed[2] === "MSG" && typeof parsed[4] === "string") encStr = parsed[4];
+					} catch {}
+					if (typeof encStr === "string" && encStr.length > 30) {
+						const decrypted = decryptCryptPadPayload(encStr, cryptKey);
+						if (decrypted) {
+							decryptedMessages.push(decrypted);
+							resetQuietTimer();
+						}
+					}
+				}
+			} catch {}
+		};
+		ws.onerror = (err) => {
+			cleanup();
+			reject(/* @__PURE__ */ new Error(`CryptPad WebSocket error: ${String(err)}`));
+		};
+	});
+}
+/**
+* Connects to the CryptPad Netflux WebSocket server, joins a channel,
+* encrypts the given message with TweetNaCl, and broadcasts it to all peers
+* in the channel (including historyKeeper).
+*/
+function broadcastChannelMessage(wsUrl, channelHex, cryptKey, message, options = {}) {
+	const { timeoutMs = 8e3, signal } = options;
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) return reject(/* @__PURE__ */ new Error("Operation aborted"));
+		const ws = new WebSocket(wsUrl);
+		let seq = 1;
+		let timeout = null;
+		let sent = false;
+		const cleanup = () => {
+			if (timeout) clearTimeout(timeout);
+			try {
+				ws.close();
+			} catch {}
+		};
+		timeout = setTimeout(() => {
+			cleanup();
+			if (sent) resolve();
+			else reject(/* @__PURE__ */ new Error(`Timeout after ${timeoutMs}ms broadcasting message to CryptPad channel "${channelHex}".`));
+		}, timeoutMs);
+		if (signal) signal.addEventListener("abort", () => {
+			cleanup();
+			reject(/* @__PURE__ */ new Error("Operation aborted"));
+		});
+		ws.onopen = () => {
+			ws.send(JSON.stringify([
+				seq++,
+				"JOIN",
+				channelHex
+			]));
+		};
+		ws.onmessage = (event) => {
+			try {
+				const raw = typeof event.data === "string" ? event.data : event.data.toString();
+				const msg = JSON.parse(raw);
+				if (!Array.isArray(msg)) return;
+				const [, peerId, cmd] = msg;
+				if (cmd === "JOIN" && typeof peerId === "string" && !sent) {
+					sent = true;
+					const encrypted = encryptCryptPadPayload(message, cryptKey);
+					ws.send(JSON.stringify([
+						seq++,
+						"MSG",
+						channelHex,
+						encrypted
+					]));
+					setTimeout(() => {
+						cleanup();
+						resolve();
+					}, 350);
+				}
+			} catch {}
+		};
+		ws.onerror = (err) => {
+			cleanup();
+			reject(/* @__PURE__ */ new Error(`CryptPad WebSocket broadcast error: ${String(err)}`));
+		};
+	});
+}
+//#endregion
+//#region src/providers/cryptpad/sheetParser.ts
+/** Converts column index (0-based) to letter: 0 -> 'A', 25 -> 'Z', 26 -> 'AA'. */
+function colIndexToLetter(colIndex) {
+	let temp = colIndex;
+	let letter = "";
+	while (temp >= 0) {
+		letter = String.fromCharCode(temp % 26 + 65) + letter;
+		temp = Math.floor(temp / 26) - 1;
+	}
+	return letter;
+}
+/**
+* Parses cell coordinates from a reference like "A1", "Sheet1!B2", or "$C$5".
+*/
+function parseCellRef(ref) {
+	const match = ref.match(/^(?:([^!]+)!)?\$?([A-Z]+)\$?(\d+)$/i);
+	if (!match) return null;
+	return {
+		sheet: match[1],
+		col: match[2].toUpperCase(),
+		row: parseInt(match[3], 10)
+	};
+}
+/**
+* Extracts the OnlyOffice real-time collaboration channel ID from decrypted pad metadata messages.
+*/
+function extractOnlyOfficeChannelId(metadataMessages) {
+	for (const raw of metadataMessages) try {
+		const parsed = JSON.parse(raw);
+		if (Array.isArray(parsed) && Array.isArray(parsed[1])) {
+			for (const edit of parsed[1]) if (Array.isArray(edit) && typeof edit[2] === "string") try {
+				const inner = JSON.parse(edit[2]);
+				if (inner?.content?.channel && typeof inner.content.channel === "string") return inner.content.channel;
+			} catch {}
+		}
+		if (parsed?.content?.channel && typeof parsed.content.channel === "string") return parsed.content.channel;
+	} catch {}
+	return null;
+}
+/**
+* Parses OnlyOffice incremental binary change records into cell coordinates and text values.
+*/
+function parseOnlyOfficeChanges(rtMessages) {
+	const cells = {};
+	for (const raw of rtMessages) try {
+		const data = JSON.parse(raw);
+		if (!Array.isArray(data.changes)) continue;
+		for (const ch of data.changes) {
+			if (!ch?.change) continue;
+			let changeStr = ch.change;
+			if (typeof changeStr !== "string") continue;
+			try {
+				changeStr = JSON.parse(changeStr);
+			} catch {}
+			const parts = changeStr.split(";");
+			if (parts.length < 2) continue;
+			const b64 = parts[1];
+			const buf = Buffer.from(b64, "base64");
+			if (buf.length === 0) continue;
+			for (let i = 0; i < buf.length - 5; i++) if (buf[i] === 8) {
+				const strLen = buf.readUInt32LE(i + 1);
+				if (strLen > 0 && strLen < 4e3 && i + 5 + strLen <= buf.length) {
+					const str = buf.subarray(i + 5, i + 5 + strLen).toString("utf16le");
+					const cellMatch = str.match(/^(?:([^!]+)!)?([A-Z]+)(\d+)$/);
+					if (cellMatch) {
+						const cellRef = `${cellMatch[1] ? `${cellMatch[1]}!` : ""}${cellMatch[2]}${cellMatch[3]}`;
+						const searchStart = i + 5 + strLen;
+						for (let j = searchStart; j < Math.min(searchStart + 30, buf.length - 5); j++) if (buf[j] === 8) {
+							const nextLen = buf.readUInt32LE(j + 1);
+							if (nextLen > 0 && nextLen < 1e4 && j + 5 + nextLen <= buf.length) cells[cellRef] = buf.subarray(j + 5, j + 5 + nextLen).toString("utf16le");
+							break;
+						}
+					}
+					if (buf.length >= 30 && i >= 40) try {
+						const c1 = buf.readUInt32LE(14);
+						const r1 = buf.readUInt32LE(18);
+						if (r1 < 1e5 && c1 < 200) {
+							const cellRef = `${colIndexToLetter(c1)}${r1 + 1}`;
+							if (!cells[cellRef] && str.trim().length > 0 && !str.includes("!")) cells[cellRef] = str;
+						}
+					} catch {}
+				}
+			}
+		}
+	} catch {}
+	return cells;
+}
+/**
+* Converts a grid of cell references (e.g. { A1: 'key', B1: 'en', A2: 'btn.save', B2: 'Save' })
+* into structured `SheetRow[]` objects using row 1 as the header column keys.
+*/
+function convertCellsToSheetRows(cells) {
+	const rowMap = /* @__PURE__ */ new Map();
+	for (const [cellRef, val] of Object.entries(cells)) {
+		const parsed = parseCellRef(cellRef);
+		if (!parsed) continue;
+		const { col, row } = parsed;
+		if (!rowMap.has(row)) rowMap.set(row, /* @__PURE__ */ new Map());
+		rowMap.get(row).set(col, val);
+	}
+	if (rowMap.size === 0) return [];
+	const sortedRowIndices = Array.from(rowMap.keys()).sort((a, b) => a - b);
+	const headerRowIdx = sortedRowIndices[0];
+	const headerCols = rowMap.get(headerRowIdx);
+	const colToHeaderName = /* @__PURE__ */ new Map();
+	for (const [col, colName] of headerCols.entries()) {
+		const trimmed = colName.trim();
+		if (trimmed.length > 0) colToHeaderName.set(col, trimmed);
+	}
+	const resultRows = [];
+	for (const rowIdx of sortedRowIndices) {
+		if (rowIdx === headerRowIdx) continue;
+		const rowCells = rowMap.get(rowIdx);
+		const sheetRow = {};
+		for (const [col, headerName] of colToHeaderName.entries()) sheetRow[headerName] = rowCells.get(col) ?? "";
+		if (sheetRow.var !== void 0 && sheetRow.key === void 0) sheetRow.key = sheetRow.var;
+		if (Object.values(sheetRow).some((v) => typeof v === "string" && v.trim().length > 0)) resultRows.push(sheetRow);
+	}
+	return resultRows;
+}
+/**
+* Groups a flat grid of cell coordinates by sheet tab name.
+* Cells without an explicit sheet prefix are assigned to `defaultSheet` (defaults to 'Sheet1').
+*/
+function groupCellsBySheet(cells, defaultSheet = "Sheet1") {
+	const result = {};
+	for (const [cellRef, val] of Object.entries(cells)) {
+		const parsed = parseCellRef(cellRef);
+		if (!parsed) continue;
+		const sheetName = parsed.sheet && parsed.sheet.trim().length > 0 ? parsed.sheet.trim() : defaultSheet;
+		if (!result[sheetName]) result[sheetName] = {};
+		const flatRef = `${parsed.col}${parsed.row}`;
+		result[sheetName][flatRef] = val;
+	}
+	if (Object.keys(result).length === 0 && Object.keys(cells).length > 0) result[defaultSheet] = { ...cells };
+	return result;
+}
+/**
+* Converts a grid of cell references into a dictionary of SheetRow arrays keyed by sheet tab name.
+*/
+function convertCellsToMultiSheetRows(cells, defaultSheet = "Sheet1") {
+	const grouped = groupCellsBySheet(cells, defaultSheet);
+	const result = {};
+	for (const [sheetName, sheetGrid] of Object.entries(grouped)) result[sheetName] = convertCellsToSheetRows(sheetGrid);
+	return result;
+}
+/**
+* Encodes a single cell update record into OnlyOffice binary format (0x08 prefix + UTF-16LE string).
+*/
+function encodeOnlyOfficeCellRecord(cellRef, value) {
+	const refBuf = Buffer.from(cellRef, "utf16le");
+	const valBuf = Buffer.from(value, "utf16le");
+	const refHeader = Buffer.alloc(5);
+	refHeader[0] = 8;
+	refHeader.writeUInt32LE(refBuf.length, 1);
+	const valHeader = Buffer.alloc(5);
+	valHeader[0] = 8;
+	valHeader.writeUInt32LE(valBuf.length, 1);
+	return Buffer.concat([
+		refHeader,
+		refBuf,
+		valHeader,
+		valBuf
+	]);
+}
+/**
+* Formats a list of cell updates into an OnlyOffice change transaction JSON string.
+*/
+function buildOnlyOfficeChangePayload(updates) {
+	const records = updates.map((u) => {
+		const colStr = typeof u.col === "number" ? colIndexToLetter(u.col) : u.col.toUpperCase();
+		return encodeOnlyOfficeCellRecord(`${u.sheet && u.sheet.trim().length > 0 ? `${u.sheet.trim()}!` : ""}${colStr}${u.row}`, u.value);
+	});
+	const changeEntry = `asc_1;${Buffer.concat(records).toString("base64")}`;
+	return JSON.stringify({ changes: [{ change: changeEntry }] });
+}
+//#endregion
+//#region src/providers/cryptpad/client.ts
+/**
+* Headless programmatic client for interacting with CryptPad documents (spreadsheets)
+* over end-to-end encrypted Netflux WebSockets without requiring a browser or user interaction.
+*/
+var CryptPadClient = class {
+	constructor(options) {
+		if (!options.url || typeof options.url !== "string") throw new Error("CryptPadClient requires a valid \"url\" option.");
+		this.parsedUrl = parsePadUrl(options.url);
+		this.password = options.password ?? process.env.CRYPTPAD_PASSWORD;
+		this.websocketUrl = options.websocketUrl;
+		this.timeoutMs = options.timeoutMs ?? 1e4;
+		if (this.parsedUrl.isPasswordProtected && !this.password) throw new Error(`CryptPad pad "${this.parsedUrl.cleanUrl}" is password protected, but no password was provided. Set "password" option or CRYPTPAD_PASSWORD environment variable.`);
+	}
+	/** Gets or derives the symmetric key and primary Netflux channel ID. */
+	getKeys() {
+		if (!this.derivedKeys) this.derivedKeys = deriveCryptPadKeys(this.parsedUrl.seed, this.password);
+		return this.derivedKeys;
+	}
+	/** Resolves the Netflux WebSocket endpoint to connect to. */
+	async getWebsocketUrl(signal) {
+		if (this.websocketUrl) return this.websocketUrl;
+		return resolveCryptPadWebsocketUrl(this.parsedUrl.origin, signal);
+	}
+	/**
+	* Fetches the complete sheet data, including raw cell coordinate mappings,
+	* multi-sheet tabs, and structured rows formatted for translation ingestion.
+	*/
+	async fetchSheetData(signal) {
+		const wsUrl = await this.getWebsocketUrl(signal);
+		const { channelHex, cryptKey } = this.getKeys();
+		const rtChannel = extractOnlyOfficeChannelId(await fetchChannelHistory(wsUrl, channelHex, cryptKey, {
+			timeoutMs: this.timeoutMs,
+			signal
+		}));
+		let cells = {};
+		if (rtChannel) cells = parseOnlyOfficeChanges(await fetchChannelHistory(wsUrl, rtChannel, cryptKey, {
+			timeoutMs: this.timeoutMs,
+			signal
+		}));
+		const multiSheets = convertCellsToMultiSheetRows(cells);
+		const sheetNames = Object.keys(multiSheets);
+		const defaultSheet = multiSheets["Sheet1"] ? "Sheet1" : sheetNames[0];
+		const defaultRows = defaultSheet && multiSheets[defaultSheet] ? multiSheets[defaultSheet] : convertCellsToSheetRows(cells);
+		const groupedCells = groupCellsBySheet(cells);
+		const sheetsResult = {};
+		for (const name of sheetNames) sheetsResult[name] = {
+			cells: groupedCells[name] ?? {},
+			rows: multiSheets[name] ?? []
+		};
+		return {
+			url: this.parsedUrl.cleanUrl,
+			cells,
+			rows: defaultRows,
+			sheets: sheetsResult,
+			sheetNames,
+			metadata: {
+				app: this.parsedUrl.app,
+				mode: this.parsedUrl.mode,
+				channelId: channelHex,
+				rtChannelId: rtChannel ?? void 0
+			}
+		};
+	}
+	/**
+	* Directly fetches tabular translation rows `[ { key: '...', en: '...', de: '...' } ]`.
+	* If `sheetName` is provided, returns rows for that specific tab.
+	*/
+	async fetchSheetRows(sheetName, signal) {
+		const result = await this.fetchSheetData(signal);
+		if (sheetName && result.sheets[sheetName]) return result.sheets[sheetName].rows;
+		return result.rows;
+	}
+	/**
+	* Broadcasts cell updates to the OnlyOffice real-time collaboration channel.
+	*/
+	async sendCellUpdates(updates, signal) {
+		if (updates.length === 0) return;
+		const rtChannel = (await this.fetchSheetData(signal)).metadata.rtChannelId;
+		if (!rtChannel) throw new Error(`CryptPad sheet "${this.parsedUrl.cleanUrl}" does not have an active OnlyOffice RT channel.`);
+		const wsUrl = await this.getWebsocketUrl(signal);
+		const { cryptKey } = this.getKeys();
+		await broadcastChannelMessage(wsUrl, rtChannel, cryptKey, buildOnlyOfficeChangePayload(updates), {
+			timeoutMs: this.timeoutMs,
+			signal
+		});
+	}
+	/**
+	* Updates or appends rows in a target sheet tab, creating new cells as needed.
+	*/
+	async writeSheetRows(sheetName, rows, options = {}) {
+		if (rows.length === 0) return 0;
+		const existingRows = (await this.fetchSheetData(options.signal)).sheets[sheetName]?.rows ?? [];
+		let keyColName = "var";
+		const firstExisting = existingRows[0];
+		const firstIncoming = rows[0];
+		if (firstExisting) {
+			if ("var" in firstExisting) keyColName = "var";
+			else if ("key" in firstExisting) keyColName = "key";
+		} else if (firstIncoming) {
+			if ("var" in firstIncoming) keyColName = "var";
+			else if ("key" in firstIncoming) keyColName = "key";
+		}
+		const colNamesSet = /* @__PURE__ */ new Set([keyColName]);
+		for (const r of existingRows) for (const k of Object.keys(r)) if (k !== "key" && k !== "var") colNamesSet.add(k);
+		for (const r of rows) for (const k of Object.keys(r)) if (k !== "key" && k !== "var") colNamesSet.add(k);
+		const colNames = Array.from(colNamesSet);
+		const updates = [];
+		colNames.forEach((name, idx) => {
+			updates.push({
+				sheet: sheetName,
+				col: colIndexToLetter(idx),
+				row: 1,
+				value: name
+			});
+		});
+		const keyToRowIdx = /* @__PURE__ */ new Map();
+		existingRows.forEach((r, idx) => {
+			const rowKey = r.var ?? r.key ?? r[keyColName];
+			if (rowKey) keyToRowIdx.set(rowKey, idx + 2);
+		});
+		let nextAvailableRow = existingRows.length + 2;
+		for (const row of rows) {
+			const rowKey = row.var ?? row.key ?? row[keyColName];
+			if (!rowKey) continue;
+			const targetRow = keyToRowIdx.get(rowKey) ?? nextAvailableRow++;
+			keyToRowIdx.set(rowKey, targetRow);
+			for (const [colName, val] of Object.entries(row)) {
+				const mappedColName = colName === "key" || colName === "var" ? keyColName : colName;
+				const colIdx = colNames.indexOf(mappedColName);
+				if (colIdx >= 0 && val !== void 0) {
+					const existingVal = existingRows[targetRow - 2]?.[mappedColName];
+					if (options.override || !existingVal || existingVal.trim().length === 0) updates.push({
+						sheet: sheetName,
+						col: colIndexToLetter(colIdx),
+						row: targetRow,
+						value: String(val)
+					});
+				}
+			}
+		}
+		await this.sendCellUpdates(updates, options.signal);
+		return updates.length;
+	}
+};
+//#endregion
+//#region src/providers/cryptpad/sheetProvider.ts
+const CRYPTPAD_SHEET_INPUT_CAPABILITIES = createCapabilitySet({
+	readTables: true,
+	publicReadNoAuth: false
+});
+/**
+* Creates a read-only {@link TranslationInputProvider} that retrieves translation tables
+* directly from password-protected or public CryptPad spreadsheets (OnlyOffice sheets)
+* using end-to-end encrypted Netflux WebSockets without requiring a browser or bot.
+*/
+function createCryptPadSheetInputProvider(options) {
+	let sources = options.sources ? [...options.sources] : [];
+	if (sources.length === 0) {
+		const singleUrl = options.url ?? process.env.CRYPTPAD_URL;
+		if (singleUrl) sources.push({
+			tableName: options.tableName ?? "translations",
+			url: singleUrl,
+			password: options.password ?? process.env.CRYPTPAD_PASSWORD
+		});
+	}
+	if (sources.length === 0) throw new Error("CryptPad Sheet provider requires at least one source (either \"sources\" array or \"url\" option/CRYPTPAD_URL).");
+	return {
+		kind: "input",
+		providerId: options.providerId ?? "cryptpad-sheet",
+		displayName: options.displayName ?? "CryptPad Sheet Input (E2EE)",
+		capabilities: CRYPTPAD_SHEET_INPUT_CAPABILITIES,
+		async readTables(request) {
+			const requested = new Set((request.tableNames ?? []).filter(Boolean));
+			const selectedSources = requested.size === 0 ? sources : sources.filter((source) => requested.has(source.tableName));
+			return {
+				tables: (await Promise.all(selectedSources.map(async (source) => {
+					const url = source.url ?? options.url ?? process.env.CRYPTPAD_URL;
+					if (!url) throw new Error(`CryptPad sheet source "${source.tableName}" does not define a URL.`);
+					const sheetData = await new CryptPadClient({
+						url,
+						password: source.password ?? options.password ?? process.env.CRYPTPAD_PASSWORD,
+						timeoutMs: options.timeoutMs
+					}).fetchSheetData(request.signal);
+					const sourceTables = [];
+					if (Array.isArray(sheetData.sheetNames) && sheetData.sheetNames.length > 1) {
+						for (const tabName of sheetData.sheetNames) if (requested.size === 0 || requested.has(tabName) || requested.has(source.tableName)) sourceTables.push({
+							tableId: `${source.tableId ?? url}#${tabName}`,
+							tableName: tabName,
+							rows: sheetData.sheets[tabName]?.rows ?? [],
+							sourcePath: url,
+							metadata: {
+								provider: "cryptpad-sheet",
+								channelId: sheetData.metadata.channelId,
+								rtChannelId: sheetData.metadata.rtChannelId,
+								sheetTab: tabName
+							}
+						});
+					}
+					if (sourceTables.length === 0) sourceTables.push({
+						tableId: source.tableId ?? url,
+						tableName: source.tableName,
+						rows: sheetData.rows,
+						sourcePath: url,
+						metadata: {
+							provider: "cryptpad-sheet",
+							channelId: sheetData.metadata.channelId,
+							rtChannelId: sheetData.metadata.rtChannelId,
+							cellCount: Object.keys(sheetData.cells).length
+						}
+					});
+					return sourceTables;
+				}))).flat(),
+				metadata: {
+					provider: "cryptpad-sheet",
+					sourceCount: selectedSources.length
+				}
+			};
+		}
+	};
+}
+//#endregion
+//#region src/providers/cryptpad/sheetOutputProvider.ts
+const CRYPTPAD_SHEET_OUTPUT_CAPABILITIES = createCapabilitySet({ writeTables: true });
+/**
+* Converts nested TranslationData `[locale][sheet][key] = value` into
+* tabular rows `Record<sheetName, SheetRow[]>`.
+*/
+function convertTranslationsToSheetRows(translations, localeMapping = {}, keyColumnName = "key") {
+	const reverseMapping = {};
+	for (const [header, norm] of Object.entries(localeMapping)) reverseMapping[norm] = header;
+	const sheetRowsMap = {};
+	for (const [locale, sheets] of Object.entries(translations)) {
+		const colHeader = reverseMapping[locale] ?? locale;
+		for (const [sheetName, keys] of Object.entries(sheets)) {
+			if (!sheetRowsMap[sheetName]) sheetRowsMap[sheetName] = /* @__PURE__ */ new Map();
+			for (const [key, value] of Object.entries(keys)) {
+				if (!sheetRowsMap[sheetName].has(key)) sheetRowsMap[sheetName].set(key, { [keyColumnName]: key });
+				sheetRowsMap[sheetName].get(key)[colHeader] = String(value);
+			}
+		}
+	}
+	const result = {};
+	for (const [sheetName, keyMap] of Object.entries(sheetRowsMap)) result[sheetName] = Array.from(keyMap.values());
+	return result;
+}
+/**
+* Creates a {@link TranslationOutputProvider} that writes translation data directly
+* into password-protected or public CryptPad spreadsheets (multi-tab OnlyOffice workbooks)
+* using end-to-end encrypted Netflux WebSockets.
+*/
+function createCryptPadSheetOutputProvider(options = {}) {
+	const url = options.url ?? process.env.CRYPTPAD_URL;
+	if (!url) throw new Error("CryptPad Sheet output provider requires a \"url\" option or CRYPTPAD_URL environment variable.");
+	const password = options.password ?? process.env.CRYPTPAD_PASSWORD;
+	return {
+		kind: "output",
+		providerId: options.providerId ?? "cryptpad-sheet",
+		displayName: options.displayName ?? "CryptPad Sheet Output (E2EE)",
+		capabilities: CRYPTPAD_SHEET_OUTPUT_CAPABILITIES,
+		async writeTranslations(payload) {
+			const client = new CryptPadClient({
+				url,
+				password,
+				timeoutMs: options.timeoutMs
+			});
+			const effectiveMapping = options.localeMapping ?? payload.localeMapping ?? {};
+			const sheetRowsMap = convertTranslationsToSheetRows(payload.translations, effectiveMapping, options.keyColumnName ?? "key");
+			const updatedSheets = [];
+			let totalUpdatedCells = 0;
+			for (const [sheetName, rows] of Object.entries(sheetRowsMap)) {
+				const count = await client.writeSheetRows(sheetName, rows, { override: options.override ?? false });
+				updatedSheets.push(sheetName);
+				totalUpdatedCells += count;
+			}
+			return {
+				wroteFiles: [url],
+				metadata: {
+					provider: "cryptpad-sheet",
+					url,
+					updatedSheets,
+					totalUpdatedCells
+				}
+			};
+		}
+	};
+}
+//#endregion
 //#region src/providers/syncEngine.ts
 function pathKey(locale, sheet, key) {
 	return `${locale}::${sheet}::${key}`;
@@ -3406,6 +4154,148 @@ function resolveSyncPlan(input, policy) {
 	};
 }
 //#endregion
+//#region src/providers/cryptpad/sheetSyncProvider.ts
+const CRYPTPAD_SHEET_SYNC_CAPABILITIES = createCapabilitySet({
+	syncBack: true,
+	writeTables: true
+});
+/**
+* Creates a {@link TranslationSyncProvider} that reconciles local translation changes
+* against a live CryptPad spreadsheet (multi-tab OnlyOffice workbook) using three-way
+* diffing and conflict policies, pushing only the resolved diffs back over Netflux.
+*/
+function createCryptPadSheetSyncProvider(options = {}) {
+	const url = options.url ?? process.env.CRYPTPAD_URL;
+	if (!url) throw new Error("CryptPad Sheet sync provider requires a \"url\" option or CRYPTPAD_URL environment variable.");
+	const password = options.password ?? process.env.CRYPTPAD_PASSWORD;
+	return {
+		kind: "sync",
+		providerId: options.providerId ?? "cryptpad-sheet",
+		displayName: options.displayName ?? "CryptPad Sheet Sync (E2EE)",
+		capabilities: CRYPTPAD_SHEET_SYNC_CAPABILITIES,
+		async syncTranslations(payload) {
+			const resolution = resolveSyncPlan({
+				baseTranslations: payload.metadata?.baseTranslations ?? payload.remoteTranslations,
+				localTranslations: payload.localTranslations,
+				remoteTranslations: payload.remoteTranslations
+			}, options.conflictPolicy ?? "manual");
+			if (resolution.appliedLocalChanges === 0) return {
+				changedKeys: 0,
+				skippedKeys: resolution.skippedConflicts,
+				metadata: {
+					reason: "no-local-diff",
+					url,
+					policy: resolution.policy
+				}
+			};
+			const client = new CryptPadClient({
+				url,
+				password,
+				timeoutMs: options.timeoutMs
+			});
+			const effectiveMapping = options.localeMapping ?? {};
+			const sheetRowsMap = convertTranslationsToSheetRows(resolution.mergedTranslations, effectiveMapping);
+			for (const [sheetName, rows] of Object.entries(sheetRowsMap)) await client.writeSheetRows(sheetName, rows, { override: options.override ?? options.conflictPolicy === "local-wins" });
+			return {
+				changedKeys: resolution.appliedLocalChanges,
+				skippedKeys: resolution.skippedConflicts,
+				metadata: {
+					provider: "cryptpad-sheet",
+					url,
+					policy: resolution.policy
+				}
+			};
+		}
+	};
+}
+//#endregion
+//#region src/providers/cryptpad/driveClient.ts
+/**
+* Headless client for inspecting and traversing encrypted CryptPad Drive folders.
+*/
+var CryptPadDriveClient = class {
+	constructor(options) {
+		if (!options.url || typeof options.url !== "string") throw new Error("CryptPadDriveClient requires a valid \"url\" option.");
+		this.parsedUrl = parsePadUrl(options.url);
+		this.password = options.password ?? process.env.CRYPTPAD_PASSWORD;
+		this.passwords = options.passwords ?? {};
+		this.timeoutMs = options.timeoutMs ?? 1e4;
+	}
+	/**
+	* Fetches the drive pad's Netflux history, decrypts all changes, and parses
+	* the hierarchical filesystem tree into a flat list of items.
+	*/
+	async listDriveItems(signal) {
+		const wsUrl = await resolveCryptPadWebsocketUrl(this.parsedUrl.origin, signal);
+		const { channelHex, cryptKey } = deriveCryptPadKeys(this.parsedUrl.seed, this.password);
+		const messages = await fetchChannelHistory(wsUrl, channelHex, cryptKey, {
+			timeoutMs: this.timeoutMs,
+			signal
+		});
+		const items = [];
+		for (const raw of messages) try {
+			const parsed = JSON.parse(raw);
+			if (parsed && typeof parsed === "object") {
+				const fileDict = parsed.files || parsed.data?.files || parsed;
+				if (fileDict && typeof fileDict === "object" && !Array.isArray(fileDict)) for (const [id, val] of Object.entries(fileDict)) {
+					if (!val || typeof val !== "object") continue;
+					const fileObj = val;
+					const title = String(fileObj.title || fileObj.name || id);
+					const href = String(fileObj.href || fileObj.url || "");
+					const typeStr = String(fileObj.type || fileObj.app || (href.includes("/sheet/") ? "sheet" : "file"));
+					const type = typeStr.includes("sheet") ? "sheet" : typeStr.includes("folder") ? "folder" : typeStr.includes("pad") ? "pad" : "file";
+					const itemUrl = href.startsWith("http") ? href : `${this.parsedUrl.origin}${href.startsWith("/") ? "" : "/"}${href}`;
+					const password = fileObj.password ?? this.passwords[itemUrl] ?? this.passwords[title] ?? this.password;
+					items.push({
+						id,
+						title,
+						type,
+						url: itemUrl,
+						password,
+						channel: typeof fileObj.channel === "string" ? fileObj.channel : void 0,
+						path: title,
+						ctime: typeof fileObj.ctime === "number" ? fileObj.ctime : void 0,
+						mtime: typeof fileObj.mtime === "number" ? fileObj.mtime : void 0
+					});
+				}
+				if (Array.isArray(parsed)) for (const entry of parsed) {
+					if (!entry || typeof entry !== "object") continue;
+					const fileObj = entry;
+					const title = String(fileObj.title || fileObj.name || "untitled");
+					const href = String(fileObj.href || fileObj.url || "");
+					const typeStr = String(fileObj.type || fileObj.app || (href.includes("/sheet/") ? "sheet" : "file"));
+					const type = typeStr.includes("sheet") ? "sheet" : typeStr.includes("folder") ? "folder" : typeStr.includes("pad") ? "pad" : "file";
+					const itemUrl = href.startsWith("http") ? href : `${this.parsedUrl.origin}${href.startsWith("/") ? "" : "/"}${href}`;
+					const password = fileObj.password ?? this.passwords[itemUrl] ?? this.passwords[title] ?? this.password;
+					items.push({
+						id: String(fileObj.id || title),
+						title,
+						type,
+						url: itemUrl,
+						password,
+						channel: typeof fileObj.channel === "string" ? fileObj.channel : void 0,
+						path: title
+					});
+				}
+			}
+		} catch {}
+		const seen = /* @__PURE__ */ new Set();
+		const deduplicated = [];
+		for (const item of items) if (item.url && !seen.has(item.url)) {
+			seen.add(item.url);
+			deduplicated.push(item);
+		}
+		return deduplicated;
+	}
+	/**
+	* Filters and returns only spreadsheets found within the drive folder.
+	*/
+	async listSheets(signal) {
+		return (await this.listDriveItems(signal)).filter((item) => item.type === "sheet" || item.url.includes("/sheet/"));
+	}
+};
+createCapabilitySet({ discoverByFolder: true });
+//#endregion
 //#region src/providers/cryptpad/fullProvider.ts
 const CRYPTPAD_WORKSPACE_OUTPUT_CAPABILITIES = createCapabilitySet({ writeTables: true });
 const CRYPTPAD_WORKSPACE_SYNC_CAPABILITIES = createCapabilitySet({
@@ -3552,6 +4442,9 @@ function createCryptPadWorkspaceSyncProvider(options, depsOverrides = {}) {
 }
 //#endregion
 //#region src/providers/cryptpad/assetProvider.ts
+/**
+* Options for configuring a CryptPad asset synchronization provider.
+*/
 const CRYPTPAD_ASSET_SYNC_CAPABILITIES = createCapabilitySet({
 	assetSync: true,
 	discoverByFolder: true
@@ -3637,7 +4530,16 @@ function createCryptPadAssetSyncProvider(options, depsOverrides = {}) {
 		displayName: options.displayName ?? "CryptPad Asset Sync",
 		capabilities: CRYPTPAD_ASSET_SYNC_CAPABILITIES,
 		async syncAssets(request) {
-			const manifest = await deps.readManifest(options.manifestPath);
+			let manifest = [];
+			if (options.manifestPath) manifest = await deps.readManifest(options.manifestPath);
+			else if (options.driveUrl) manifest = (await new CryptPadDriveClient({
+				url: options.driveUrl,
+				password: options.password
+			}).listDriveItems(request.signal)).filter((item) => item.type !== "folder" && !item.url.includes("/sheet/")).map((item) => ({
+				assetId: item.id || item.title,
+				relativePath: item.path || item.title,
+				sourceUrl: item.url
+			}));
 			const downloaded = [];
 			const updated = [];
 			const skipped = [];
@@ -3735,6 +4637,16 @@ function createDefaultProviderCatalog() {
 				name: "Google Drive Folder Discovery",
 				metadata: { authRequired: true }
 			},
+			{
+				providerId: "cryptpad-sheet",
+				sourceId: "cryptpad-sheet-url",
+				kind: "table",
+				name: "CryptPad Sheet (E2EE OnlyOffice)",
+				metadata: {
+					authRequired: false,
+					passwordSupported: true
+				}
+			},
 			{
 				providerId: "cryptpad-csv",
 				sourceId: "cryptpad-csv-url",
@@ -3948,12 +4860,32 @@ function createInputProvider(providerId, options) {
 				displayName: typeof options.displayName === "string" ? options.displayName : void 0
 			});
 		}
+		case "cryptpad-sheet":
+		case "cryptpad": return createCryptPadSheetInputProvider({
+			sources: Array.isArray(options.sources) ? options.sources : void 0,
+			url: typeof options.url === "string" ? options.url : void 0,
+			password: typeof options.password === "string" ? options.password : void 0,
+			tableName: typeof options.tableName === "string" ? options.tableName : void 0,
+			providerId: typeof options.providerId === "string" ? options.providerId : void 0,
+			displayName: typeof options.displayName === "string" ? options.displayName : void 0,
+			timeoutMs: typeof options.timeoutMs === "number" ? options.timeoutMs : void 0
+		});
 		default: throw new Error(`Unsupported input provider: "${providerId}"`);
 	}
 }
 function createOutputProvider(providerId, options) {
 	switch (providerId) {
 		case "google-sheets": return createGoogleSheetsOutputProvider(options);
+		case "cryptpad-sheet":
+		case "cryptpad": return createCryptPadSheetOutputProvider({
+			url: typeof options.url === "string" ? options.url : void 0,
+			password: typeof options.password === "string" ? options.password : void 0,
+			override: options.override === true,
+			localeMapping: typeof options.localeMapping === "object" && options.localeMapping !== null ? options.localeMapping : void 0,
+			providerId: typeof options.providerId === "string" ? options.providerId : void 0,
+			displayName: typeof options.displayName === "string" ? options.displayName : void 0,
+			timeoutMs: typeof options.timeoutMs === "number" ? options.timeoutMs : void 0
+		});
 		case "cryptpad-workspace":
 			if (typeof options.filePath !== "string" || options.filePath.trim().length === 0) throw new Error("cryptpad-workspace output provider requires a non-empty \"filePath\" option.");
 			return createCryptPadWorkspaceOutputProvider({
@@ -3969,6 +4901,17 @@ function createOutputProvider(providerId, options) {
 function createSyncProvider(providerId, options) {
 	switch (providerId) {
 		case "google-sheets": return createGoogleSheetsSyncProvider(options);
+		case "cryptpad-sheet":
+		case "cryptpad": return createCryptPadSheetSyncProvider({
+			url: typeof options.url === "string" ? options.url : void 0,
+			password: typeof options.password === "string" ? options.password : void 0,
+			override: options.override === true,
+			conflictPolicy: options.conflictPolicy === "remote-wins" || options.conflictPolicy === "local-wins" || options.conflictPolicy === "manual" ? options.conflictPolicy : void 0,
+			localeMapping: typeof options.localeMapping === "object" && options.localeMapping !== null ? options.localeMapping : void 0,
+			providerId: typeof options.providerId === "string" ? options.providerId : void 0,
+			displayName: typeof options.displayName === "string" ? options.displayName : void 0,
+			timeoutMs: typeof options.timeoutMs === "number" ? options.timeoutMs : void 0
+		});
 		case "cryptpad-workspace":
 			if (typeof options.filePath !== "string" || options.filePath.trim().length === 0) throw new Error("cryptpad-workspace sync provider requires a non-empty \"filePath\" option.");
 			return createCryptPadWorkspaceSyncProvider({
@@ -3984,13 +4927,18 @@ function createSyncProvider(providerId, options) {
 }
 function createAssetSyncProvider(providerId, options) {
 	switch (providerId) {
-		case "cryptpad-assets":
-			if (typeof options.manifestPath !== "string" || options.manifestPath.trim().length === 0) throw new Error("cryptpad-assets sync provider requires a non-empty \"manifestPath\" option.");
+		case "cryptpad-assets": {
+			const hasManifest = typeof options.manifestPath === "string" && options.manifestPath.trim().length > 0;
+			const hasDrive = typeof options.driveUrl === "string" && options.driveUrl.trim().length > 0;
+			if (!hasManifest && !hasDrive) throw new Error("cryptpad-assets sync provider requires a non-empty \"manifestPath\" option.");
 			return createCryptPadAssetSyncProvider({
-				manifestPath: options.manifestPath,
+				manifestPath: typeof options.manifestPath === "string" ? options.manifestPath : void 0,
+				driveUrl: typeof options.driveUrl === "string" ? options.driveUrl : void 0,
+				password: typeof options.password === "string" ? options.password : void 0,
 				providerId: typeof options.providerId === "string" ? options.providerId : void 0,
 				displayName: typeof options.displayName === "string" ? options.displayName : void 0
 			});
+		}
 		default: throw new Error(`Unsupported asset sync provider: "${providerId}"`);
 	}
 }
@@ -4307,4 +5255,4 @@ function migrateProjectToV3(options = {}) {
 //#region src/index.ts
 var src_default = getSpreadSheetData;
 //#endregion
-export { CRYPTPAD_ASSET_SYNC_CAPABILITIES, CRYPTPAD_CSV_INPUT_CAPABILITIES, CRYPTPAD_WORKSPACE_OUTPUT_CAPABILITIES, CRYPTPAD_WORKSPACE_SYNC_CAPABILITIES, DEFAULT_IMAGE_EXTENSIONS, DEFAULT_WAIT_SECONDS, EMPTY_PROVIDER_CAPABILITIES, GOOGLE_SHEETS_PROVIDER_CAPABILITIES, GcpApiError, OPERATION_CAPABILITY_REQUIREMENTS, PROVIDER_CAPABILITIES, assertOperationCapabilities, assertRequiredCapabilities, assertValidProviderRuntimeConfig, buildGoogleAuth, buildManifest, buildSyncPlan, columnIndexToLetter, convertFromDataJsonFormat, convertToDataJsonFormat, createAuthClient, createCapabilitySet, createCryptPadAssetSyncProvider, createCryptPadCsvInputProvider, createCryptPadWorkspaceOutputProvider, createCryptPadWorkspaceSyncProvider, createDefaultProviderCatalog, createGoogleSheetsInputProvider, createGoogleSheetsOutputProvider, createGoogleSheetsSyncProvider, createInMemoryProviderCatalogProvider, createLocaleMapping, createProvidersFromRuntimeConfig, createSpreadsheet, src_default as default, entriesToSeedKeys, entriesToTranslationData, exportDoc, filterValidLocales, findLocalChanges, getGoogleTranslateCode, getLanguagePrefix, getLocaleDisplayName, getMultipleSpreadSheetsData, getNormalizedLocaleForHeader, getOriginalHeaderForLocale, getSpreadSheetData, getTranslationSummary, grantDrivePermissions, handleBidirectionalSync, hasRequiredCapabilities, inferLocaleFromDocName, ingestDoc, isValidLocale, manageDriveTranslations, mapLegacyGoogleOptionsToProviderConfig, mergeMultipleTranslationData, mergeSheets, migrateProjectToV3, missingCapabilities, moveSpreadsheetToFolder, normalizeExtension, normalizeLocaleCode, normalizePrivateKey, parseDocContent, processRawRows, readManifest, readPublicSheet, requiresGoogleAuthForRuntimeConfig, resolveLocaleWithFallback, resolveSyncPlan, runProviderPipeline, sanitizeFolderName, scanDriveFolderForDocs, scanDriveFolderForSpreadsheets, setupWIF, slugifyKey, syncDriveImages, updateSpreadsheetWithLocalChanges, validateCredentials, validateEnv, validateImageDirectory, validateProviderRuntimeConfig, wait, walkDirectory, withRetry, writeLanguageDataFile, writeLocalesFile, writeManifest, writeTranslationFiles };
+export { CRYPTPAD_ASSET_SYNC_CAPABILITIES, CRYPTPAD_CSV_INPUT_CAPABILITIES, CRYPTPAD_SHEET_INPUT_CAPABILITIES, CRYPTPAD_WORKSPACE_OUTPUT_CAPABILITIES, CRYPTPAD_WORKSPACE_SYNC_CAPABILITIES, CryptPadClient, DEFAULT_IMAGE_EXTENSIONS, DEFAULT_WAIT_SECONDS, EMPTY_PROVIDER_CAPABILITIES, GOOGLE_SHEETS_PROVIDER_CAPABILITIES, GcpApiError, OPERATION_CAPABILITY_REQUIREMENTS, PROVIDER_CAPABILITIES, assertOperationCapabilities, assertRequiredCapabilities, assertValidProviderRuntimeConfig, buildGoogleAuth, buildManifest, buildSyncPlan, columnIndexToLetter, convertCellsToSheetRows, convertFromDataJsonFormat, convertToDataJsonFormat, createAuthClient, createCapabilitySet, createCryptPadAssetSyncProvider, createCryptPadCsvInputProvider, createCryptPadSheetInputProvider, createCryptPadWorkspaceOutputProvider, createCryptPadWorkspaceSyncProvider, createDefaultProviderCatalog, createGoogleSheetsInputProvider, createGoogleSheetsOutputProvider, createGoogleSheetsSyncProvider, createInMemoryProviderCatalogProvider, createLocaleMapping, createProvidersFromRuntimeConfig, createSpreadsheet, decryptCryptPadPayload, src_default as default, deriveCryptPadKeys, entriesToSeedKeys, entriesToTranslationData, exportDoc, extractOnlyOfficeChannelId, fetchChannelHistory, filterValidLocales, findLocalChanges, getGoogleTranslateCode, getLanguagePrefix, getLocaleDisplayName, getMultipleSpreadSheetsData, getNormalizedLocaleForHeader, getOriginalHeaderForLocale, getSpreadSheetData, getTranslationSummary, grantDrivePermissions, handleBidirectionalSync, hasRequiredCapabilities, inferLocaleFromDocName, ingestDoc, isValidLocale, manageDriveTranslations, mapLegacyGoogleOptionsToProviderConfig, mergeMultipleTranslationData, mergeSheets, migrateProjectToV3, missingCapabilities, moveSpreadsheetToFolder, normalizeExtension, normalizeLocaleCode, normalizePrivateKey, parseDocContent, parseOnlyOfficeChanges, parsePadUrl, processRawRows, readManifest, readPublicSheet, requiresGoogleAuthForRuntimeConfig, resolveCryptPadWebsocketUrl, resolveLocaleWithFallback, resolveSyncPlan, runProviderPipeline, sanitizeFolderName, scanDriveFolderForDocs, scanDriveFolderForSpreadsheets, setupWIF, slugifyKey, syncDriveImages, updateSpreadsheetWithLocalChanges, validateCredentials, validateEnv, validateImageDirectory, validateProviderRuntimeConfig, wait, walkDirectory, withRetry, writeLanguageDataFile, writeLocalesFile, writeManifest, writeTranslationFiles };