@frogbotai/piece-google-sheets 0.29.0 → 0.31.0

package/dist/rows.js

@@ -2,20 +2,31 @@ import { createHash } from 'node:crypto';
 import { parse } from 'csv-parse/sync';
 import { z } from 'zod';
 import { defineAction } from './define.js';
-import { batch, batchOutput, cells, columnIndex, mapRows, readInput, readRows, readValues, requestOptions, rowNumber, rowOutput, rowValues, sheetInput, sheetRange, updatedRow, updateOutput, valueInputOption, worksheet, } from './shared.js';
-const writeInput = sheetInput.extend({ values: rowValues, valueInputOption });
-const writeOutput = z.object({ row: rowNumber, updates: updateOutput });
+import { batch, batchOutput, cells, columnIndex, mapRows, readInput, readRows, readValues, requestOptions, rowNumber, rowOutput, rowValues, sheetInput, sheetRange, updatedRow, updateOutput, valueInputOption, worksheet } from './shared.js';
+const writeInput = sheetInput.extend({
+    values: rowValues,
+    valueInputOption
+});
+const writeOutput = z.object({
+    row: rowNumber,
+    updates: updateOutput
+});
 async function appendValues(args) {
     const sheet = await worksheet(args);
     const { data } = await args.client.sheets.spreadsheets.values.append({
         spreadsheetId: args.input.spreadsheetId,
         range: sheetRange(sheet.title, 'A:A'),
         valueInputOption: args.input.valueInputOption,
-        requestBody: { majorDimension: 'ROWS', values: [cells(args.input.values)] },
+        requestBody: {
+            majorDimension: 'ROWS',
+            values: [
+                cells(args.input.values)
+            ]
+        }
     }, requestOptions(args.req));
     return {
         row: updatedRow(data.updates?.updatedRange),
-        updates: updateOutput.parse(data.updates ?? {}),
+        updates: updateOutput.parse(data.updates ?? {})
     };
 }
 export const appendRow = defineAction({
@@ -24,10 +35,10 @@ export const appendRow = defineAction({
     input: writeInput,
     output: writeOutput,
     idempotent: false,
-    run: appendValues,
+    run: appendValues
 });
 const insertInput = writeInput.extend({
-    afterRow: z.number().int().nonnegative().max(9_999_999).default(1),
+    afterRow: z.number().int().nonnegative().max(9_999_999).default(1)
 });
 export const insertRow = defineAction({
     slug: 'insertRow',
@@ -35,7 +46,7 @@ export const insertRow = defineAction({
     input: insertInput,
     output: writeOutput,
     idempotent: false,
-    async run(args) {
+    async run (args) {
         const sheet = await worksheet(args);
         const row = args.input.afterRow + 1;
         await batch(args, [
@@ -45,89 +56,119 @@ export const insertRow = defineAction({
                         sheetId: args.input.sheetId,
                         dimension: 'ROWS',
                         startIndex: row - 1,
-                        endIndex: row,
+                        endIndex: row
                     },
-                    inheritFromBefore: row > 1,
-                },
-            },
+                    inheritFromBefore: row > 1
+                }
+            }
         ]);
         const { data } = await args.client.sheets.spreadsheets.values.update({
             spreadsheetId: args.input.spreadsheetId,
             range: sheetRange(sheet.title, `${row}:${row}`),
             valueInputOption: args.input.valueInputOption,
-            requestBody: { majorDimension: 'ROWS', values: [cells(args.input.values)] },
+            requestBody: {
+                majorDimension: 'ROWS',
+                values: [
+                    cells(args.input.values)
+                ]
+            }
         }, requestOptions(args.req));
-        return { row, updates: updateOutput.parse(data) };
-    },
+        return {
+            row,
+            updates: updateOutput.parse(data)
+        };
+    }
+});
+const updateInput = writeInput.extend({
+    row: rowNumber
 });
-const updateInput = writeInput.extend({ row: rowNumber });
 export const updateRow = defineAction({
     slug: 'updateRow',
     description: 'Update a row; empty and null values leave existing cells unchanged.',
     input: updateInput,
     output: writeOutput,
     idempotent: true,
-    async run(args) {
+    async run (args) {
         const sheet = await worksheet(args);
         const { data } = await args.client.sheets.spreadsheets.values.update({
             spreadsheetId: args.input.spreadsheetId,
             range: sheetRange(sheet.title, `${args.input.row}:${args.input.row}`),
             valueInputOption: args.input.valueInputOption,
-            requestBody: { majorDimension: 'ROWS', values: [cells(args.input.values, true)] },
+            requestBody: {
+                majorDimension: 'ROWS',
+                values: [
+                    cells(args.input.values, true)
+                ]
+            }
         }, requestOptions(args.req));
-        return { row: args.input.row, updates: updateOutput.parse(data) };
-    },
+        return {
+            row: args.input.row,
+            updates: updateOutput.parse(data)
+        };
+    }
 });
 const updatesInput = sheetInput.extend({
-    rows: z.array(z.object({ row: rowNumber.optional(), values: rowValues })),
-    valueInputOption,
+    rows: z.array(z.object({
+        row: rowNumber.optional(),
+        values: rowValues
+    })),
+    valueInputOption
 });
-const updatesOutput = z
-    .object({
+const updatesOutput = z.object({
     spreadsheetId: z.string().nullish(),
     totalUpdatedRows: z.number().nullish(),
     totalUpdatedCells: z.number().nullish(),
-    responses: z.array(updateOutput).nullish(),
-})
-    .passthrough();
+    responses: z.array(updateOutput).nullish()
+}).passthrough();
 export const updateRows = defineAction({
     slug: 'updateRows',
     description: 'Batch-update rows, skipping entries without a row number and leaving empty cells unchanged.',
     input: updatesInput,
     output: updatesOutput,
     idempotent: true,
-    async run(args) {
-        const rows = args.input.rows.filter((row) => row.row != null);
-        if (!rows.length)
-            return { totalUpdatedRows: 0, totalUpdatedCells: 0, responses: [] };
+    async run (args) {
+        const rows = args.input.rows.filter((row)=>row.row != null);
+        if (!rows.length) return {
+            totalUpdatedRows: 0,
+            totalUpdatedCells: 0,
+            responses: []
+        };
         const sheet = await worksheet(args);
         const { data } = await args.client.sheets.spreadsheets.values.batchUpdate({
             spreadsheetId: args.input.spreadsheetId,
             requestBody: {
                 valueInputOption: args.input.valueInputOption,
-                data: rows.map((row) => ({
-                    range: sheetRange(sheet.title, `${row.row}:${row.row}`),
-                    majorDimension: 'ROWS',
-                    values: [cells(row.values, true)],
-                })),
-            },
+                data: rows.map((row)=>({
+                        range: sheetRange(sheet.title, `${row.row}:${row.row}`),
+                        majorDimension: 'ROWS',
+                        values: [
+                            cells(row.values, true)
+                        ]
+                    }))
+            }
         }, requestOptions(args.req));
         return updatesOutput.parse(data);
-    },
+    }
 });
 const appendRowsInput = sheetInput.extend({
     data: z.discriminatedUnion('format', [
-        z.object({ format: z.literal('columns'), rows: z.array(rowValues) }),
-        z.object({ format: z.literal('json'), rows: z.array(z.record(z.string(), z.json())) }),
-        z.object({ format: z.literal('csv'), text: z.string() }),
+        z.object({
+            format: z.literal('columns'),
+            rows: z.array(rowValues)
+        }),
+        z.object({
+            format: z.literal('json'),
+            rows: z.array(z.record(z.string(), z.json()))
+        }),
+        z.object({
+            format: z.literal('csv'),
+            text: z.string()
+        })
     ]),
     headerRow: rowNumber.default(1),
     overwrite: z.boolean().default(false),
-    duplicateColumn: z
-        .string()
-        .regex(/^[A-Z]{1,3}$/)
-        .optional(),
-    valueInputOption,
+    duplicateColumn: z.string().regex(/^[A-Z]{1,3}$/).optional(),
+    valueInputOption
 });
 export const appendRows = defineAction({
     slug: 'appendRows',
@@ -136,197 +177,227 @@ export const appendRows = defineAction({
     output: z.object({
         insertedRows: z.number().int().nonnegative(),
         updates: updateOutput.or(updatesOutput),
-        clearedRanges: z.array(z.string()).optional(),
+        clearedRanges: z.array(z.string()).optional()
     }),
     idempotent: false,
-    async run(args) {
+    async run (args) {
         const { input, client, req } = args;
         const sheet = await worksheet(args);
         const headerRange = sheetRange(sheet.title, `${input.headerRow}:${input.headerRow}`);
-        const headers = ((await readValues({ ...args, spreadsheetId: input.spreadsheetId, range: headerRange }))[0] ??
-            []).map(String);
+        const headers = ((await readValues({
+            ...args,
+            spreadsheetId: input.spreadsheetId,
+            range: headerRange
+        }))[0] ?? []).map(String);
         let rows;
-        if (input.data.format === 'columns')
-            rows = input.data.rows.map((row) => cells(row));
+        if (input.data.format === 'columns') rows = input.data.rows.map((row)=>cells(row));
         else if (input.data.format === 'csv') {
-            if (!headers.length)
-                throw new Error('CSV import requires a populated worksheet header row.');
+            if (!headers.length) throw new Error('CSV import requires a populated worksheet header row.');
             const records = parse(input.data.text, {
                 columns: true,
                 bom: true,
-                skip_empty_lines: true,
+                skip_empty_lines: true
             });
-            rows = records.map((record) => {
-                const normalized = Object.fromEntries(Object.entries(record).map(([key, value]) => [key.trim().toLowerCase(), value]));
-                return headers.map((header) => normalized[header.trim().toLowerCase()] ?? '');
+            rows = records.map((record)=>{
+                const normalized = Object.fromEntries(Object.entries(record).map(([key, value])=>[
+                        key.trim().toLowerCase(),
+                        value
+                    ]));
+                return headers.map((header)=>normalized[header.trim().toLowerCase()] ?? '');
             });
-        }
-        else {
+        } else {
             const records = input.data.rows;
-            const additions = [...new Set(records.flatMap(Object.keys))].filter((key) => !headers.includes(key));
+            const additions = [
+                ...new Set(records.flatMap(Object.keys))
+            ].filter((key)=>!headers.includes(key));
             headers.push(...additions);
             if (additions.length) {
                 await client.sheets.spreadsheets.values.update({
                     spreadsheetId: input.spreadsheetId,
                     range: headerRange,
                     valueInputOption: 'USER_ENTERED',
-                    requestBody: { values: [headers] },
+                    requestBody: {
+                        values: [
+                            headers
+                        ]
+                    }
                 }, requestOptions(req));
             }
-            rows = records.map((record) => cells(headers.map((header) => record[header] ?? '')));
+            rows = records.map((record)=>cells(headers.map((header)=>record[header] ?? '')));
         }
         if (input.overwrite) {
             const start = input.headerRow + 1;
-            const updates = rows.length
-                ? updatesOutput.parse((await client.sheets.spreadsheets.values.batchUpdate({
-                    spreadsheetId: input.spreadsheetId,
-                    requestBody: {
-                        valueInputOption: input.valueInputOption,
-                        data: [
-                            {
-                                range: sheetRange(sheet.title, `A${start}`),
-                                majorDimension: 'ROWS',
-                                values: rows,
-                            },
-                        ],
-                    },
-                }, requestOptions(req))).data)
-                : { totalUpdatedRows: 0 };
+            const updates = rows.length ? updatesOutput.parse((await client.sheets.spreadsheets.values.batchUpdate({
+                spreadsheetId: input.spreadsheetId,
+                requestBody: {
+                    valueInputOption: input.valueInputOption,
+                    data: [
+                        {
+                            range: sheetRange(sheet.title, `A${start}`),
+                            majorDimension: 'ROWS',
+                            values: rows
+                        }
+                    ]
+                }
+            }, requestOptions(req))).data) : {
+                totalUpdatedRows: 0
+            };
             const end = sheet.gridProperties?.rowCount ?? start + rows.length;
-            const clearedRanges = start + rows.length <= end
-                ? ((await client.sheets.spreadsheets.values.batchClear({
-                    spreadsheetId: input.spreadsheetId,
-                    requestBody: {
-                        ranges: [sheetRange(sheet.title, `${start + rows.length}:${end}`)],
-                    },
-                }, requestOptions(req))).data.clearedRanges ?? [])
-                : [];
-            return { insertedRows: rows.length, updates, clearedRanges };
+            const clearedRanges = start + rows.length <= end ? (await client.sheets.spreadsheets.values.batchClear({
+                spreadsheetId: input.spreadsheetId,
+                requestBody: {
+                    ranges: [
+                        sheetRange(sheet.title, `${start + rows.length}:${end}`)
+                    ]
+                }
+            }, requestOptions(req))).data.clearedRanges ?? [] : [];
+            return {
+                insertedRows: rows.length,
+                updates,
+                clearedRanges
+            };
         }
         if (input.duplicateColumn) {
             const index = columnIndex(input.duplicateColumn);
             const existing = await readValues({
                 ...args,
                 spreadsheetId: input.spreadsheetId,
-                range: sheetRange(sheet.title),
+                range: sheetRange(sheet.title)
             });
-            const keys = new Set(existing
-                .filter((row) => index < Math.max(headers.length, row.length))
-                .map((row) => String(row[index] ?? '')
-                .trim()
-                .toLowerCase()));
-            rows = rows.filter((row, rowIndex) => {
+            const keys = new Set(existing.filter((row)=>index < Math.max(headers.length, row.length)).map((row)=>String(row[index] ?? '').trim().toLowerCase()));
+            rows = rows.filter((row, rowIndex)=>{
                 const original = input.data.format === 'columns' ? input.data.rows[rowIndex] : undefined;
-                const value = original
-                    ? Array.isArray(original)
-                        ? original[index]
-                        : original[input.duplicateColumn]
-                    : row[index];
+                const value = original ? Array.isArray(original) ? original[index] : original[input.duplicateColumn] : row[index];
                 return value == null || !keys.has(String(value).trim().toLowerCase());
             });
         }
-        if (!rows.length)
-            return { insertedRows: 0, updates: {} };
+        if (!rows.length) return {
+            insertedRows: 0,
+            updates: {}
+        };
         const { data } = await client.sheets.spreadsheets.values.append({
             spreadsheetId: input.spreadsheetId,
             range: sheetRange(sheet.title, 'A:A'),
             valueInputOption: input.valueInputOption,
-            requestBody: { majorDimension: 'ROWS', values: rows },
+            requestBody: {
+                majorDimension: 'ROWS',
+                values: rows
+            }
         }, requestOptions(req));
-        return { insertedRows: rows.length, updates: updateOutput.parse(data.updates ?? {}) };
-    },
+        return {
+            insertedRows: rows.length,
+            updates: updateOutput.parse(data.updates ?? {})
+        };
+    }
+});
+const deleteInput = sheetInput.extend({
+    row: rowNumber
 });
-const deleteInput = sheetInput.extend({ row: rowNumber });
 export const deleteRow = defineAction({
     slug: 'deleteRow',
     description: 'Delete a row and shift following rows upward.',
     input: deleteInput,
     output: batchOutput,
     idempotent: false,
-    run: async (args) => batchOutput.parse(await batch(args, [
-        {
-            deleteDimension: {
-                range: {
-                    sheetId: args.input.sheetId,
-                    dimension: 'ROWS',
-                    startIndex: args.input.row - 1,
-                    endIndex: args.input.row,
-                },
-            },
-        },
-    ])),
+    run: async (args)=>batchOutput.parse(await batch(args, [
+            {
+                deleteDimension: {
+                    range: {
+                        sheetId: args.input.sheetId,
+                        dimension: 'ROWS',
+                        startIndex: args.input.row - 1,
+                        endIndex: args.input.row
+                    }
+                }
+            }
+        ]))
 });
 const rowSelection = z.discriminatedUnion('mode', [
-    z
-        .object({ mode: z.literal('range'), startRow: rowNumber, endRow: rowNumber.optional() })
-        .refine((value) => value.endRow == null || value.endRow >= value.startRow, 'End row must not precede start row.'),
-    z.object({ mode: z.literal('list'), rows: z.array(rowNumber).min(1) }),
+    z.object({
+        mode: z.literal('range'),
+        startRow: rowNumber,
+        endRow: rowNumber.optional()
+    }).refine((value)=>value.endRow == null || value.endRow >= value.startRow, 'End row must not precede start row.'),
+    z.object({
+        mode: z.literal('list'),
+        rows: z.array(rowNumber).min(1)
+    })
 ]);
-const deleteRowsInput = sheetInput.extend({ selection: rowSelection });
+const deleteRowsInput = sheetInput.extend({
+    selection: rowSelection
+});
 export const deleteRows = defineAction({
     slug: 'deleteRows',
     description: 'Delete a row range or distinct row numbers in descending order.',
     input: deleteRowsInput,
     output: z.object({
-        deletedRanges: z.array(z.object({ startRow: rowNumber, endRow: rowNumber })),
-        result: batchOutput,
+        deletedRanges: z.array(z.object({
+            startRow: rowNumber,
+            endRow: rowNumber
+        })),
+        result: batchOutput
     }),
     idempotent: false,
-    async run(args) {
+    async run (args) {
         const selection = args.input.selection;
-        const ranges = selection.mode === 'range'
-            ? [{ startRow: selection.startRow, endRow: selection.endRow ?? selection.startRow }]
-            : [...new Set(selection.rows)]
-                .sort((a, b) => b - a)
-                .map((row) => ({ startRow: row, endRow: row }));
+        const ranges = selection.mode === 'range' ? [
+            {
+                startRow: selection.startRow,
+                endRow: selection.endRow ?? selection.startRow
+            }
+        ] : [
+            ...new Set(selection.rows)
+        ].sort((a, b)=>b - a).map((row)=>({
+                startRow: row,
+                endRow: row
+            }));
         return {
             deletedRanges: ranges,
-            result: batchOutput.parse(await batch(args, ranges.map(({ startRow, endRow }) => ({
-                deleteDimension: {
-                    range: {
-                        sheetId: args.input.sheetId,
-                        dimension: 'ROWS',
-                        startIndex: startRow - 1,
-                        endIndex: endRow,
-                    },
-                },
-            })))),
+            result: batchOutput.parse(await batch(args, ranges.map(({ startRow, endRow })=>({
+                    deleteDimension: {
+                        range: {
+                            sheetId: args.input.sheetId,
+                            dimension: 'ROWS',
+                            startIndex: startRow - 1,
+                            endIndex: endRow
+                        }
+                    }
+                }))))
         };
-    },
+    }
 });
 const searchInput = readInput.extend({
-    column: z
-        .string()
-        .regex(/^[A-Z]{1,3}$/)
-        .default('A'),
+    column: z.string().regex(/^[A-Z]{1,3}$/).default('A'),
     searchValue: z.string().default(''),
     exactMatch: z.boolean().default(false),
     startRow: rowNumber.default(1),
-    limit: rowNumber.default(1),
+    limit: rowNumber.default(1)
 });
 async function searchRows(args) {
-    const rows = await readRows({ ...args, input: { ...args.input, useHeaderNames: false } }, args.input.startRow);
+    const rows = await readRows({
+        ...args,
+        input: {
+            ...args.input,
+            useHeaderNames: false
+        }
+    }, args.input.startRow);
     const { input } = args;
-    const matches = rows
-        .filter(({ values }) => input.searchValue === '' ||
-        (input.exactMatch
-            ? values[input.column] === input.searchValue
-            : values[input.column]?.toLowerCase().includes(input.searchValue.toLowerCase())))
-        .slice(0, input.limit);
-    if (!input.useHeaderNames || !matches.length)
-        return matches;
+    const matches = rows.filter(({ values })=>input.searchValue === '' || (input.exactMatch ? values[input.column] === input.searchValue : values[input.column]?.toLowerCase().includes(input.searchValue.toLowerCase()))).slice(0, input.limit);
+    if (!input.useHeaderNames || !matches.length) return matches;
     const sheet = await worksheet(args);
     const headers = (await readValues({
         ...args,
         spreadsheetId: input.spreadsheetId,
-        range: sheetRange(sheet.title, `${input.headerRow}:${input.headerRow}`),
+        range: sheetRange(sheet.title, `${input.headerRow}:${input.headerRow}`)
     }))[0] ?? [];
-    return matches.map((row) => mapRows({
-        values: [Object.values(row.values)],
-        startRow: row.row,
-        headers,
-        useHeaderNames: true,
-    })[0]);
+    return matches.map((row)=>mapRows({
+            values: [
+                Object.values(row.values)
+            ],
+            startRow: row.row,
+            headers,
+            useHeaderNames: true
+        })[0]);
 }
 export const findRows = defineAction({
     slug: 'findRows',
@@ -334,70 +405,101 @@ export const findRows = defineAction({
     input: searchInput,
     output: z.array(rowOutput),
     idempotent: true,
-    run: searchRows,
+    run: searchRows
+});
+const findOrCreateInput = searchInput.extend({
+    values: rowValues,
+    valueInputOption
 });
-const findOrCreateInput = searchInput.extend({ values: rowValues, valueInputOption });
 export const findOrCreateRow = defineAction({
     slug: 'findOrCreateRow',
     description: 'Return the first matching row, or append supplied values when no row matches.',
     input: findOrCreateInput,
-    output: rowOutput.extend({ found: z.boolean(), created: z.boolean() }),
+    output: rowOutput.extend({
+        found: z.boolean(),
+        created: z.boolean()
+    }),
     idempotent: false,
-    async run(args) {
-        const [found] = await searchRows({ ...args, input: { ...args.input, limit: 1 } });
-        if (found)
-            return { ...found, found: true, created: false };
+    async run (args) {
+        const [found] = await searchRows({
+            ...args,
+            input: {
+                ...args.input,
+                limit: 1
+            }
+        });
+        if (found) return {
+            ...found,
+            found: true,
+            created: false
+        };
         const result = await appendValues(args);
         let headers = [];
         if (args.input.useHeaderNames) {
             const sheet = await worksheet(args);
-            headers =
-                (await readValues({
-                    ...args,
-                    spreadsheetId: args.input.spreadsheetId,
-                    range: sheetRange(sheet.title, `${args.input.headerRow}:${args.input.headerRow}`),
-                }))[0] ?? [];
+            headers = (await readValues({
+                ...args,
+                spreadsheetId: args.input.spreadsheetId,
+                range: sheetRange(sheet.title, `${args.input.headerRow}:${args.input.headerRow}`)
+            }))[0] ?? [];
         }
         return {
             ...mapRows({
-                values: [cells(args.input.values)],
+                values: [
+                    cells(args.input.values)
+                ],
                 startRow: result.row,
                 headers,
-                useHeaderNames: args.input.useHeaderNames,
+                useHeaderNames: args.input.useHeaderNames
             })[0],
             found: false,
-            created: true,
+            created: true
         };
-    },
+    }
+});
+const getRowInput = readInput.extend({
+    row: rowNumber
 });
-const getRowInput = readInput.extend({ row: rowNumber });
 export const getRow = defineAction({
     slug: 'getRow',
     description: 'Read one physical row, returning found=false when it is beyond the populated range.',
     input: getRowInput,
     output: z.union([
-        rowOutput.extend({ found: z.literal(true) }),
-        z.object({ found: z.literal(false), row: z.null() }),
+        rowOutput.extend({
+            found: z.literal(true)
+        }),
+        z.object({
+            found: z.literal(false),
+            row: z.null()
+        })
     ]),
     idempotent: true,
-    async run(args) {
+    async run (args) {
         const [row] = await readRows(args, args.input.row, args.input.row);
-        return row ? { found: true, ...row } : { found: false, row: null };
-    },
+        return row ? {
+            found: true,
+            ...row
+        } : {
+            found: false,
+            row: null
+        };
+    }
+});
+const getRowsInput = readInput.extend({
+    skipHeaders: z.boolean().default(false)
 });
-const getRowsInput = readInput.extend({ skipHeaders: z.boolean().default(false) });
 export const getRows = defineAction({
     slug: 'getRows',
     description: 'Read all populated rows, optionally skipping the header and preceding rows.',
     input: getRowsInput,
     output: z.array(rowOutput),
     idempotent: true,
-    run: (args) => readRows(args, args.input.skipHeaders ? args.input.headerRow + 1 : 1),
+    run: (args)=>readRows(args, args.input.skipHeaders ? args.input.headerRow + 1 : 1)
 });
 const nextInput = readInput.extend({
     startRow: rowNumber.default(1),
     batchSize: rowNumber.default(1),
-    memoryKey: z.string().min(1).default('row_number'),
+    memoryKey: z.string().min(1).default('row_number')
 });
 export const getNextRows = defineAction({
     slug: 'getNextRows',
@@ -405,50 +507,63 @@ export const getNextRows = defineAction({
     input: nextInput,
     output: z.array(rowOutput),
     idempotent: false,
-    async run(args) {
+    async run (args) {
         const { req, input } = args;
         requestOptions(req);
-        const owner = req.user ? [req.user.collection, req.user.id] : ['developer'];
+        const owner = req.user ? [
+            req.user.collection,
+            req.user.id
+        ] : [
+            'developer'
+        ];
         if (req.user && (!req.user.collection || req.user.id == null)) {
             throw new Error('A persistent Sheets cursor requires an identifiable owner.');
         }
         let instanceSlug;
-        for (const instance of req.frogbot.config.pieces.instances) {
-            if (instance.piece !== 'google-sheets')
-                continue;
-            const client = await instance.client({ req }).catch(() => undefined);
+        for (const instance of req.frogbot.config.pieces.instances){
+            if (instance.piece !== 'google-sheets') continue;
+            const client = await instance.client({
+                req
+            }).catch(()=>undefined);
             if (client === args.client) {
                 instanceSlug = instance.slug;
                 break;
             }
         }
         if (!instanceSlug) {
-            throw new Error('Register the Google Sheets piece instance in your configuration before using a persistent cursor.');
+            throw new Error("Use this Google Sheets instance in an agent's tools or triggers, or in `connections`, before using a persistent cursor.");
         }
-        const key = `pieces:google-sheets:cursor:${createHash('sha256')
-            .update(JSON.stringify([owner, instanceSlug, input.spreadsheetId, input.sheetId, input.memoryKey]))
-            .digest('hex')}`;
-        return req.frogbot.kv.lock(`${key}:lock`, 30_000, async ({ signal: lease }) => {
-            const signal = req.signal ? AbortSignal.any([req.signal, lease]) : lease;
+        const key = `pieces:google-sheets:cursor:${createHash('sha256').update(JSON.stringify([
+            owner,
+            instanceSlug,
+            input.spreadsheetId,
+            input.sheetId,
+            input.memoryKey
+        ])).digest('hex')}`;
+        return req.frogbot.kv.lock(`${key}:lock`, 30_000, async ({ signal: lease })=>{
+            const signal = req.signal ? AbortSignal.any([
+                req.signal,
+                lease
+            ]) : lease;
             signal.throwIfAborted();
             const stored = await req.frogbot.kv.get(key);
             const start = stored == null ? input.startRow : z.number().int().positive().max(10_000_001).parse(stored);
             const lockedArgs = {
                 ...args,
                 req: new Proxy(req, {
-                    get: (target, property) => property === 'signal' ? signal : Reflect.get(target, property),
-                }),
+                    get: (target, property)=>property === 'signal' ? signal : Reflect.get(target, property)
+                })
             };
             let rows = await readRows(lockedArgs, start, start + input.batchSize - 1);
             if (rows.length < input.batchSize) {
                 rows = (await readRows(lockedArgs, start)).slice(0, input.batchSize);
             }
             signal.throwIfAborted();
-            if (rows.length)
-                await req.frogbot.kv.set(key, start + rows.length);
+            if (rows.length) await req.frogbot.kv.set(key, start + rows.length);
             signal.throwIfAborted();
             return rows;
         });
-    },
+    }
 });
+
 //# sourceMappingURL=rows.js.map