zitejs 0.10.0-start.7 → 0.10.0-start.8

package/dist/cjs/sync/lib.js

@@ -83,6 +83,7 @@ const FIELD_TYPE_MAP = {
     formula: "any",
     created_at: "string",
     updated_at: "string",
+    created_by: "string",
     updated_by: "string",
 };
 /**
@@ -108,7 +109,7 @@ const FIELD_INPUT_TYPE_MAP = {
  * rather than typed and then refused at runtime.
  *
  * Mirrors `COMPUTED_FIELD_TYPES` in the product's own `shared/bases/fields`.
- * The first six are rejected by `createRecordDataSchema` — each has a
+ * The first seven are rejected by `createRecordDataSchema` — each has a
  * `refine(val => val == null)`, so a non-null write errors (null is a no-op
  * clear). `created_at` / `updated_at` are refused differently: they have no
  * column at all, so a write is silently dropped, which is the worse outcome to
@@ -120,6 +121,7 @@ const READ_ONLY_FIELD_TYPES = new Set([
     "source",
     "formula",
     "autonumber",
+    "created_by",
     "updated_by",
     "created_at",
     "updated_at",
@@ -260,13 +262,8 @@ function fieldJsdoc(schemaField, table, schema) {
     const parts = [];
     if (table.primaryFieldId === schemaField.id)
         parts.push("Primary field");
-    if (def.type === "created_at" ||
-        def.type === "updated_at" ||
-        def.type === "lookup" ||
-        def.type === "formula" ||
-        def.type === "autonumber") {
+    if (READ_ONLY_FIELD_TYPES.has(def.type))
         parts.push("Read-only");
-    }
     if (def.type === "linked_record") {
         const tpl = def.template;
         if (tpl.tableId) {

package/dist/cjs/vite/index.js

@@ -75,11 +75,12 @@ function ziteId() {
         name: "vite-plugin-zite-id",
         enforce: "pre",
         async transform(code, id) {
-            if (!validExtensions.has(path_1.default.extname(id)) ||
-                id.includes("node_modules")) {
+            // TanStack's route code splitting moves a route's component into its own module, `route.tsx?tsr-split=…`.
+            const file = id.split("?")[0];
+            if (!validExtensions.has(path_1.default.extname(file)) || file.includes("node_modules")) {
                 return null;
             }
-            const relativePath = path_1.default.relative(cwd, id);
+            const relativePath = path_1.default.relative(cwd, file);
             try {
                 const ast = (0, parser_1.parse)(code, {
                     sourceType: "module",
@@ -134,6 +135,10 @@ function ziteId() {
                             if (!isTagged) {
                                 return;
                             }
+                            // A module split from one already tagged keeps its tags.
+                            if (openingElement.attributes?.some((attr) => attr.type === "JSXAttribute" && attr.name?.name === "data-zite-id")) {
+                                return;
+                            }
                             const line = openingElement.loc?.start?.line ?? 0;
                             const col = openingElement.loc?.start?.column ?? 0;
                             const dataComponentId = `${relativePath}|${line}|${col}`;

package/dist/cjs/vite/index.test.js

@@ -6,16 +6,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = __importDefault(require("path"));
 const vitest_1 = require("vitest");
 const index_js_1 = require("./index.js");
-async function transform(code) {
+async function transform(code, file = 'src/App.tsx') {
     const plugin = (0, index_js_1.ziteId)();
     const handler = plugin.transform;
-    const result = await handler(code, path_1.default.join(process.cwd(), 'src/App.tsx'));
+    const result = await handler(code, path_1.default.join(process.cwd(), file));
     if (!result) {
         throw new Error('transform returned null');
     }
     return result.code;
 }
 (0, vitest_1.describe)('ziteId', () => {
+    (0, vitest_1.it)("tags a route's component that TanStack split into its own module, by the source file", async () => {
+        const code = await transform('const a = <p>Hi</p>;', 'src/routes/index.tsx?tsr-split=component');
+        (0, vitest_1.expect)(code).toContain('<p data-zite-id="src/routes/index.tsx|1|10" data-zite-editable="true">');
+    });
+    (0, vitest_1.it)('leaves an element that already has its tag', async () => {
+        const code = await transform('const a = <p data-zite-id="src/routes/index.tsx|1|10">Hi</p>;');
+        (0, vitest_1.expect)(code.match(/data-zite-id/g)).toHaveLength(1);
+    });
     (0, vitest_1.it)('tags html and svg elements without a component name', async () => {
         const code = await transform('const a = <div><svg><path d="M0" /></svg><p>Hello</p></div>;');
         (0, vitest_1.expect)(code).toContain('<div data-zite-id="src/App.tsx|1|10">');

package/dist/esm/start/airtable/arrayFields.d.ts

@@ -0,0 +1,10 @@
+export type AirtableFieldShape = {
+    type: string;
+    options?: unknown;
+};
+export declare const isArrayValuedAirtableField: (field: AirtableFieldShape) => boolean;
+export declare const airtableEqualsFormula: ({ field, fieldName, value, }: {
+    field: AirtableFieldShape;
+    fieldName: string;
+    value: string;
+}) => string;

package/dist/esm/start/airtable/arrayFields.js

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+const ARRAY_VALUED_AIRTABLE_FIELD_TYPES = new Set([
+    'multipleLookupValues',
+    'multipleSelects',
+    'multipleRecordLinks',
+    'multipleCollaborators',
+    'multipleAttachments',
+]);
+const resultTypeOptionsSchema = z.object({
+    result: z.object({ type: z.string().optional() }).optional(),
+});
+export const isArrayValuedAirtableField = (field) => {
+    if (field.type === 'formula' || field.type === 'rollup') {
+        const resultType = resultTypeOptionsSchema.safeParse(field.options).data
+            ?.result?.type;
+        return resultType
+            ? ARRAY_VALUED_AIRTABLE_FIELD_TYPES.has(resultType)
+            : false;
+    }
+    return ARRAY_VALUED_AIRTABLE_FIELD_TYPES.has(field.type);
+};
+const ELEMENT_SEPARATOR = ', ';
+export const airtableEqualsFormula = ({ field, fieldName, value, }) => {
+    if (!isArrayValuedAirtableField(field)) {
+        return `${fieldName}=${value}`;
+    }
+    const needle = `"${ELEMENT_SEPARATOR}" & ${value} & "${ELEMENT_SEPARATOR}"`;
+    const haystack = `"${ELEMENT_SEPARATOR}" & ARRAYJOIN(${fieldName}) & "${ELEMENT_SEPARATOR}"`;
+    return `SEARCH(${needle}, ${haystack}) != ""`;
+};

package/dist/esm/start/airtable/dispatch.d.ts

@@ -0,0 +1,54 @@
+/** As `@fillout/zite`'s `IntegrationFieldMappingType`, from zite.lock. */
+export type AirtableFieldMapping = {
+    mapping: {
+        sdkName: string;
+    };
+    fieldType?: string;
+    fieldName?: string;
+    fieldOptions?: Record<string, unknown>;
+};
+export type AirtableFieldMappings = Record<string, AirtableFieldMapping>;
+export type AirtableNameMappings = {
+    bases: Record<string, {
+        mapping: {
+            sdkName: string;
+        };
+        tables: Record<string, {
+            mapping: {
+                sdkName: string;
+            };
+            primaryFieldId?: string;
+            fields: AirtableFieldMappings;
+        }>;
+    }>;
+};
+/** An app's Airtable integration as its build declares it. */
+export type AirtableSettings = {
+    baseId: string;
+    nameMappings: AirtableNameMappings | null;
+};
+/** Answers one Airtable request; the platform puts the connection's token on it. */
+export type AirtableFetch = (path: string, init: {
+    method: string;
+    body?: unknown;
+}) => Promise<Response>;
+export type AirtableContext = {
+    settings: AirtableSettings;
+    fetch: AirtableFetch;
+    /** One request's reads, so the same read twice in a request goes to Airtable once. */
+    reads?: Map<string, Promise<unknown>>;
+    sleep?: (ms: number) => Promise<void>;
+};
+/** The npm SDK's error, whose shape apps (and the goldens) see: not an `Error`. */
+export declare class AirtableError {
+    error: string;
+    message: string;
+    statusCode: number;
+    constructor(error: string, message: string, statusCode: number);
+    toString(): string;
+}
+export declare function airtableRecordToSdkNames(record: Record<string, any> | undefined, fieldMappings: AirtableFieldMappings | undefined): Record<string, any> | undefined;
+/** A Duration cell (seconds) as HH:mm:ss, keeping seconds and fractions (ZIT-3889). */
+export declare function formatAirtableDuration(durationSeconds: number): string;
+/** One Airtable table call, as classic's dispatch runs it. */
+export declare function executeAirtableCall(context: AirtableContext, methodName: string, params: any): Promise<any>;

package/dist/esm/start/airtable/dispatch.js

@@ -0,0 +1,465 @@
+// Ported from restly's apps/cloudflare-lambda/src/integrations/airtable.ts (`executeAirtableCall`), classic's
+// dispatch, which the Airtable goldens are recorded from, with a fetch client in place of the npm SDK. Keep the two
+// in step. Differences: fields come back by id from every request, so a rename since the lock never unmaps one;
+// the schema is the lock's (`nameMappings`), as the build bakes it; the per-base limiter is gone.
+import { filtersToFormula as buildFiltersFormula } from "./formulas.js";
+const SDK_ID_FIELD = "id";
+const UNIQUE_RECORD_ID_KEY = "recordID";
+const AIRTABLE_BATCH_SIZE = 10;
+/** The npm SDK's error, whose shape apps (and the goldens) see: not an `Error`. */
+export class AirtableError {
+    error;
+    message;
+    statusCode;
+    constructor(error, message, statusCode) {
+        this.error = error;
+        this.message = message;
+        this.statusCode = statusCode;
+    }
+    toString() {
+        return [this.message, "(", this.error, ")", this.statusCode ? `[Http code ${this.statusCode}]` : ""].join("");
+    }
+}
+// =============================================================================
+// Field mapping
+// =============================================================================
+const sdkNameToFieldId = (fieldMappings) => {
+    const map = {};
+    for (const [fieldId, info] of Object.entries(fieldMappings ?? {})) {
+        if (info?.mapping?.sdkName)
+            map[info.mapping.sdkName] = fieldId;
+    }
+    return map;
+};
+const fieldIdToSdkName = (fieldMappings) => {
+    const map = {};
+    for (const [fieldId, info] of Object.entries(fieldMappings ?? {})) {
+        if (info?.mapping?.sdkName)
+            map[fieldId] = info.mapping.sdkName;
+    }
+    return map;
+};
+function transformFiltersToFieldIds(filters, fieldMappings) {
+    if (!filters || !fieldMappings)
+        return filters;
+    const ids = sdkNameToFieldId(fieldMappings);
+    const result = {};
+    for (const [key, value] of Object.entries(filters)) {
+        result[key === "id" || key === SDK_ID_FIELD ? key : (ids[key] ?? key)] = value;
+    }
+    return result;
+}
+function transformRecordToFieldIds(record, fieldMappings) {
+    if (!record || !fieldMappings)
+        return record;
+    const ids = sdkNameToFieldId(fieldMappings);
+    const result = {};
+    for (const [key, value] of Object.entries(record)) {
+        if (key === "id" || key === SDK_ID_FIELD || key === UNIQUE_RECORD_ID_KEY)
+            continue;
+        result[ids[key] ?? key] = value;
+    }
+    return result;
+}
+export function airtableRecordToSdkNames(record, fieldMappings) {
+    if (!record)
+        return undefined;
+    if (!fieldMappings)
+        return record;
+    const names = fieldIdToSdkName(fieldMappings);
+    const result = {};
+    for (const [key, value] of Object.entries(record)) {
+        if (key === "id" || key === UNIQUE_RECORD_ID_KEY) {
+            result[key] = value;
+            continue;
+        }
+        result[names[key] ?? key] = value;
+    }
+    return result;
+}
+/** The table's fields as zite.lock records them; fields a legacy lock names no further are left out. */
+const lockSchema = (tableId, table) => {
+    if (!table)
+        return undefined;
+    const fields = Object.entries(table.fields).flatMap(([id, field]) => field.fieldName
+        ? [
+            {
+                id,
+                name: field.fieldName,
+                type: field.fieldType ?? "singleLineText",
+                ...(field.fieldOptions ? { options: field.fieldOptions } : {}),
+            },
+        ]
+        : []);
+    return fields.length ? { id: tableId, primaryFieldId: table.primaryFieldId, fields } : undefined;
+};
+// =============================================================================
+// Values
+// =============================================================================
+/** For writes: dates, linked records, attachments, ratings, text. */
+function processColumnValues(columnValues, tableSchema) {
+    if (!tableSchema)
+        return columnValues;
+    const result = { ...columnValues };
+    for (const columnId of Object.keys(columnValues)) {
+        const field = tableSchema.fields.find((f) => f.id === columnId || f.name === columnId);
+        if (!field)
+            continue;
+        const value = columnValues[columnId];
+        if (value === undefined || value === null)
+            continue;
+        // An empty object means an unmapped field.
+        if (typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0) {
+            result[columnId] = undefined;
+            continue;
+        }
+        if (field.type === "multipleRecordLinks") {
+            if (!Array.isArray(value))
+                result[columnId] = value === "" ? [] : [value];
+        }
+        else if (field.type === "date" || field.type === "dateTime") {
+            if (value === "") {
+                result[columnId] = undefined;
+            }
+            else {
+                const dateValue = new Date(value);
+                if (isNaN(dateValue.getTime())) {
+                    throw new Error(`Invalid date provided for field ${field.name}: ${value}`);
+                }
+                if (field.type === "date") {
+                    const startOfDay = new Date(dateValue);
+                    startOfDay.setUTCHours(0, 0, 0, 0);
+                    result[columnId] = startOfDay.toISOString();
+                }
+                else {
+                    result[columnId] = dateValue.toISOString();
+                }
+            }
+        }
+        else if (field.type === "multipleAttachments") {
+            if (Array.isArray(value) && value.length !== 0) {
+                const attachments = value
+                    .map((v) => {
+                    if (!v || typeof v !== "object" || !v.url)
+                        return undefined;
+                    return { url: v.url, filename: v.filename || v.url.split("/").pop() };
+                })
+                    .filter((v) => v !== undefined);
+                if (attachments.length > 0)
+                    result[columnId] = attachments;
+            }
+        }
+        else if (field.type === "rating") {
+            const max = field.options?.max;
+            if (max && typeof value === "number" && value > max) {
+                throw new Error(`Value ${value} surpasses Airtable max value setting on the rating field "${field.name}"`);
+            }
+            if (typeof value === "number" && value <= 0)
+                result[columnId] = undefined;
+        }
+        else if (field.type === "singleLineText" || field.type === "multilineText") {
+            if (Array.isArray(value))
+                result[columnId] = value.join(", ");
+            else if (typeof value !== "string")
+                result[columnId] = String(value);
+        }
+        else if (field.type === "barcode") {
+            result[columnId] = String(value);
+        }
+    }
+    return result;
+}
+/** A Duration cell (seconds) as HH:mm:ss, keeping seconds and fractions (ZIT-3889). */
+export function formatAirtableDuration(durationSeconds) {
+    const duration = Math.abs(durationSeconds);
+    const pad = (n) => (n < 10 ? `0${n}` : `${n}`);
+    const hours = Math.floor(duration / 3600);
+    const minutes = Math.floor((duration % 3600) / 60);
+    const seconds = Math.floor(duration % 60);
+    const milliseconds = Math.round((duration % 1) * 1000);
+    const fraction = milliseconds > 0 ? `.${`${milliseconds}`.padStart(3, "0").replace(/0+$/, "")}` : "";
+    return `${durationSeconds < 0 ? "-" : ""}${pad(hours)}:${pad(minutes)}:${pad(seconds)}${fraction}`;
+}
+const isErrorObject = (value) => typeof value === "object" && value !== null && typeof value.error === "string";
+const isNaNValue = (value) => typeof value === "object" && value !== null && value.specialValue === "NaN";
+/** For reads: durations, barcodes, AI text, buttons, broken formulas and rollups. */
+function getRecordFields(rawRecord, tableSchema) {
+    const fields = { ...rawRecord.fields };
+    if (tableSchema) {
+        for (const fieldId of Object.keys(fields)) {
+            const value = fields[fieldId];
+            const field = tableSchema.fields.find((f) => f.id === fieldId);
+            if (!field)
+                continue;
+            if (field.type === "multilineText" || field.type === "richText") {
+                if (value === "\n")
+                    fields[fieldId] = "";
+            }
+            else if (field.type === "barcode" && value && typeof value === "object") {
+                fields[fieldId] = value.text || "";
+            }
+            else if (field.type === "duration" && typeof value === "number") {
+                fields[fieldId] = formatAirtableDuration(value);
+            }
+            else if (field.type === "button" && value && typeof value === "object") {
+                fields[fieldId] = value.url;
+            }
+            else if (field.type === "aiText" && value && typeof value === "object") {
+                const text = value.value;
+                fields[fieldId] = text !== undefined && text !== null && text !== "" ? text : undefined;
+            }
+            else if (field.type === "formula") {
+                const numeric = field.options?.result?.type === "number";
+                if ((numeric && typeof value !== "number") || isNaNValue(value) || isErrorObject(value)) {
+                    fields[fieldId] = undefined;
+                }
+            }
+            else if (field.type === "rollup") {
+                const numeric = field.options?.rollup?.type === "number";
+                if ((numeric && typeof value !== "number") || isNaNValue(value) || isErrorObject(value) || value === null) {
+                    fields[fieldId] = undefined;
+                }
+            }
+        }
+    }
+    return { ...fields, [UNIQUE_RECORD_ID_KEY]: rawRecord.id, id: rawRecord.id };
+}
+// =============================================================================
+// Requests
+// =============================================================================
+const sleepMs = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+// As the npm SDK raises it (`_checkStatusForError`, `_getErrorForNonObjectBody`).
+const sdkError = async (response) => {
+    const status = response.status;
+    const body = await response.json().catch(() => undefined);
+    const { type, message } = (body?.error ?? {});
+    if (status === 401) {
+        return new AirtableError("AUTHENTICATION_REQUIRED", "You should provide valid api key to perform this operation", status);
+    }
+    if (status === 403)
+        return new AirtableError("NOT_AUTHORIZED", "You are not authorized to perform this operation", status);
+    if (status === 404)
+        return new AirtableError("NOT_FOUND", message ?? "Could not find what you are looking for", status);
+    if (status === 413)
+        return new AirtableError("REQUEST_TOO_LARGE", "Request body is too large", status);
+    if (status === 422) {
+        return new AirtableError(type ?? "UNPROCESSABLE_ENTITY", message ?? "The operation cannot be processed", status);
+    }
+    if (status === 429) {
+        return new AirtableError("TOO_MANY_REQUESTS", "You have made too many requests in a short period of time. Please retry your request later", status);
+    }
+    if (status === 500)
+        return new AirtableError("SERVER_ERROR", "Try again. If the problem persists, contact support.", status);
+    if (status === 503) {
+        return new AirtableError("SERVICE_UNAVAILABLE", "The service is temporarily unavailable. Please retry shortly.", status);
+    }
+    if (typeof body !== "object" || body === null || Array.isArray(body)) {
+        return new AirtableError("UNEXPECTED_ERROR", "The response from Airtable was invalid JSON. Please try again soon.", status);
+    }
+    return new AirtableError(type ?? "UNEXPECTED_ERROR", message ?? "An unexpected error occurred", status);
+};
+const MIN_RETRY_DELAY_MS = 200;
+/** One bounded backoff on 429s, as classic's: five attempts, jittered over a doubling delay. */
+async function withBackoff(operation, name, sleep, maxAttempts = 5, startingDelay = 1000, maxDelay = 600_000) {
+    let attempt = 0;
+    let delay = startingDelay;
+    while (attempt < maxAttempts) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            const rateLimited = error?.statusCode === 429 ||
+                error?.status === 429 ||
+                error?.message?.includes("429") ||
+                error?.message?.toLowerCase().includes("rate limit");
+            if (!rateLimited)
+                throw error;
+            attempt++;
+            if (attempt >= maxAttempts) {
+                console.warn(`[Airtable429] ${name} attempt ${attempt}/${maxAttempts}: max retries exhausted, giving up`);
+                throw Object.assign(new Error("Airtable rate limit exceeded after maximum retries"), {
+                    status: 429,
+                    originalError: error,
+                });
+            }
+            const jittered = MIN_RETRY_DELAY_MS + Math.floor(Math.random() * (delay - MIN_RETRY_DELAY_MS));
+            console.warn(`[Airtable429] ${name} attempt ${attempt}/${maxAttempts}: retrying in ${jittered}ms`);
+            await sleep(jittered);
+            delay = Math.min(delay * 2, maxDelay);
+        }
+    }
+    throw new Error("Unexpected end of Airtable backoff loop");
+}
+const segment = (id) => encodeURIComponent(id);
+// =============================================================================
+// Dispatch
+// =============================================================================
+/** One Airtable table call, as classic's dispatch runs it. */
+export async function executeAirtableCall(context, methodName, params) {
+    const tableId = params?.tableId;
+    if (!tableId)
+        throw new Error("Airtable calls require tableId in params");
+    const baseId = context.settings.baseId || params.baseId;
+    if (!baseId)
+        throw new Error("Airtable calls require baseId (from integration settings or params)");
+    const tables = context.settings.nameMappings?.bases?.[baseId]?.tables;
+    const fieldMappings = tables?.[tableId]?.fields;
+    const tableSchema = lockSchema(tableId, tables?.[tableId]);
+    const sleep = context.sleep ?? sleepMs;
+    const tablePath = `/v0/${segment(baseId)}/${segment(tableId)}`;
+    // A write makes any read this request already made stale.
+    const send = async (path, init) => {
+        if (init.method !== "GET" && !path.endsWith("/listRecords"))
+            context.reads?.clear();
+        return context.fetch(path, init);
+    };
+    const read = (key, load) => {
+        if (!context.reads)
+            return load();
+        const held = context.reads.get(key);
+        if (held)
+            return held;
+        const loading = load();
+        context.reads.set(key, loading);
+        loading.catch(() => context.reads?.delete(key));
+        return loading;
+    };
+    const getRecord = (recordTableId, recordId) => read(`get:${baseId}:${recordTableId}:${recordId}`, async () => {
+        const response = await send(`/v0/${segment(baseId)}/${segment(recordTableId)}/${segment(recordId)}?returnFieldsByFieldId=true`, { method: "GET" });
+        if (!response.ok)
+            throw await sdkError(response);
+        return (await response.json());
+    });
+    const filterFormula = async (filters) => {
+        if (!filters || Object.keys(filters).length === 0)
+            return undefined;
+        const transformed = transformFiltersToFieldIds(filters, fieldMappings);
+        if (!transformed)
+            return undefined;
+        // A linked-record filter names the record by its primary field, which costs a lookup each.
+        const getPrimaryFieldForRecord = async (linkedTableId, recordId) => {
+            try {
+                const record = await withBackoff(() => getRecord(linkedTableId, recordId), "linkedRecord", sleep);
+                const primaryFieldId = tables?.[linkedTableId]?.primaryFieldId;
+                const value = primaryFieldId !== undefined ? record.fields[primaryFieldId] : Object.values(record.fields)[0];
+                return value !== undefined && value !== null ? String(value) : undefined;
+            }
+            catch {
+                return undefined;
+            }
+        };
+        return buildFiltersFormula({
+            filters: transformed,
+            tableSchema: tableSchema,
+            getPrimaryFieldForRecord,
+        });
+    };
+    const toSdk = (record) => airtableRecordToSdkNames(getRecordFields(record, tableSchema), fieldMappings);
+    switch (methodName) {
+        case "findOne": {
+            const { id, filters } = params;
+            if (id) {
+                return withBackoff(async () => {
+                    try {
+                        return toSdk(await getRecord(tableId, id));
+                    }
+                    catch (error) {
+                        // A missing record is no record; 401 and 403 go up, where the platform refreshes a token.
+                        if (error?.statusCode === 404)
+                            return undefined;
+                        throw error;
+                    }
+                }, "findOne", sleep);
+            }
+            const filterByFormula = await filterFormula(filters);
+            return withBackoff(async () => {
+                const list = await listRecords({ maxRecords: 1, ...(filterByFormula ? { filterByFormula } : {}) });
+                return list.records.length === 0 ? undefined : toSdk(list.records[0]);
+            }, "findOne", sleep);
+        }
+        case "findAll": {
+            const { filters, limit, offset } = params;
+            const filterByFormula = await filterFormula(filters);
+            return withBackoff(async () => {
+                const json = await listRecords({
+                    ...(filterByFormula ? { filterByFormula } : {}),
+                    ...(limit ? { pageSize: limit } : {}),
+                    ...(offset ? { offset } : {}),
+                });
+                return {
+                    records: (json.records || []).map(toSdk).filter((r) => r !== undefined),
+                    offset: json.offset,
+                    hasMore: json.offset !== undefined,
+                };
+            }, "findAll", sleep);
+        }
+        case "create": {
+            const { record } = params;
+            if (!record)
+                return undefined;
+            return withBackoff(async () => {
+                const fields = processColumnValues(transformRecordToFieldIds(record, fieldMappings) || record, tableSchema);
+                const [created] = await writeRecords("POST", [{ fields }]);
+                return toSdk(created);
+            }, "create", sleep);
+        }
+        case "bulkCreate": {
+            const { records } = params;
+            if (!records || records.length === 0)
+                return [];
+            // Airtable takes at most 10 records a request.
+            const prepared = records.map((r) => ({
+                fields: processColumnValues(transformRecordToFieldIds(r, fieldMappings) || r, tableSchema),
+            }));
+            const results = [];
+            for (let i = 0; i < prepared.length; i += AIRTABLE_BATCH_SIZE) {
+                const created = await withBackoff(() => writeRecords("POST", prepared.slice(i, i + AIRTABLE_BATCH_SIZE)), "bulkCreate", sleep);
+                for (const r of created)
+                    results.push(toSdk(r));
+            }
+            return results;
+        }
+        case "update": {
+            const { id, record } = params;
+            if (!id || !record)
+                return undefined;
+            return withBackoff(async () => {
+                const fields = processColumnValues(transformRecordToFieldIds(record, fieldMappings) || record, tableSchema);
+                const [updated] = await writeRecords("PATCH", [{ id, fields }]);
+                return { id, fields: toSdk(updated) };
+            }, "update", sleep);
+        }
+        case "delete": {
+            const { id } = params;
+            if (!id)
+                throw new Error("Delete requires id parameter");
+            return withBackoff(async () => {
+                const response = await send(`${tablePath}/${segment(id)}`, { method: "DELETE" });
+                if (!response.ok)
+                    throw await sdkError(response);
+                const deleted = (await response.json());
+                return { success: true, id: deleted.id };
+            }, "delete", sleep);
+        }
+        default:
+            throw new Error(`Unknown Airtable method: ${methodName}`);
+    }
+    async function listRecords(body) {
+        const request = { returnFieldsByFieldId: true, ...body };
+        return read(`list:${baseId}:${tableId}:${JSON.stringify(request)}`, async () => {
+            const response = await send(`${tablePath}/listRecords`, { method: "POST", body: request });
+            if (!response.ok) {
+                const error = new Error(`Airtable API error: ${await response.text()}`);
+                error.statusCode = response.status;
+                throw error;
+            }
+            return (await response.json());
+        });
+    }
+    async function writeRecords(method, records) {
+        const response = await send(tablePath, { method, body: { records, typecast: true, returnFieldsByFieldId: true } });
+        if (!response.ok)
+            throw await sdkError(response);
+        return (await response.json()).records;
+    }
+}