zitejs 0.9.109 → 0.9.111

package/dist/cjs/backend/index.d.ts

@@ -61,7 +61,13 @@ export type ZiteStreamInterface = {
 export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream extends boolean = false, TSchedule extends ZiteSchedule | undefined = undefined, TWebhook extends ZiteWebhook | undefined = undefined, TRawInput = TInput> {
     description?: string;
     inputSchema?: SchemaLike<TInput, TRawInput>;
-    outputSchema?: SchemaLike<TOutput>;
+    /**
+     * Documentation only — never validated, and `unknown` so it cannot compete
+     * with `execute` for `TOutput`. A nullable column reads as `T | undefined`
+     * while its schema says `.nullable()`; making both inference sites failed the
+     * build on the difference.
+     */
+    outputSchema?: SchemaLike<unknown>;
     stream?: TStream;
     authenticated?: boolean;
     /**

package/dist/cjs/runtime/filterConditionTypes.test-d.d.ts

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

package/dist/cjs/runtime/filterConditionTypes.test-d.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+(0, vitest_1.describe)("FilterCondition in/notIn", () => {
+    // The idiom that regressed. `.filter(Boolean)` does not narrow in TypeScript,
+    // so this is `(string | undefined)[]` — compiling at all is the assertion.
+    (0, vitest_1.it)("accepts .map(…).filter(Boolean) over a nullable column", () => {
+        const keys = routes.map((r) => r.compositeRouteKey).filter(Boolean);
+        (0, vitest_1.expectTypeOf)(keys).toEqualTypeOf();
+        (0, vitest_1.expectTypeOf)().toMatchTypeOf();
+        (0, vitest_1.expectTypeOf)().toMatchTypeOf();
+    });
+    // One array of a union, not a union of arrays.
+    (0, vitest_1.it)("collapses a nullable column to a single array type", () => {
+        (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    });
+    // The unwrapping that the conditional exists for: an array-valued column is
+    // filtered by its ELEMENT type, not by arrays of arrays.
+    (0, vitest_1.it)("still unwraps an array-valued column to its element type", () => {
+        (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    });
+    (0, vitest_1.it)("leaves a plain scalar column alone", () => {
+        (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    });
+});
+(0, vitest_1.describe)("RecordFilters", () => {
+    // Through the keyed wrapper, which is how app code actually reaches it.
+    (0, vitest_1.it)("accepts the idiom on a nullable key", () => {
+        const filters = {
+            compositeRouteKey: {
+                in: routes.map((r) => r.compositeRouteKey).filter(Boolean),
+            },
+        };
+        (0, vitest_1.expectTypeOf)(filters).toMatchTypeOf();
+    });
+    (0, vitest_1.it)("accepts an element-typed `in` on an array column", () => {
+        const filters = { tags: { in: ["urgent"] } };
+        (0, vitest_1.expectTypeOf)(filters).toMatchTypeOf();
+    });
+});

package/dist/cjs/runtime/index.d.ts

@@ -8,6 +8,11 @@
  * the operands buys little while breaking real migrated code: dates are ISO
  * strings here but 1.0 accepted `number | Date` on every comparison, and
  * `contains` was `any`.
+ *
+ * On `in`/`notIn` the `[]` sits OUTSIDE the conditional. A naked `V`
+ * distributes, so a nullable column produced `string[] | undefined[]` — two
+ * separate array types, neither of which accepts the `(string | undefined)[]`
+ * that `.map(…).filter(Boolean)` yields.
  */
 export type FilterCondition<V> = {
     /** Substring match (text fields) or "has any of these" (linked records). */
@@ -15,9 +20,9 @@ export type FilterCondition<V> = {
     /** Not equal, or — against `null` — "is set". */
     not?: V | null;
     /** An empty array matches NOTHING — the SDK's filters convert to the nested format, where `in: []` is "is one of nothing". */
-    in?: V extends Array<infer E> ? E[] : V[];
+    in?: (V extends Array<infer E> ? E : V)[];
     /** An empty array applies no filter at all — "is not one of nothing" is always true. */
-    notIn?: V extends Array<infer E> ? E[] : V[];
+    notIn?: (V extends Array<infer E> ? E : V)[];
     lt?: V | number | Date;
     lte?: V | number | Date;
     gt?: V | number | Date;

package/dist/cjs/sync/lib.d.ts

@@ -1,5 +1,6 @@
 import type { PublicFieldDefinition } from "../types/fields.js";
 import type { Database } from "../types/tables.js";
+import { type SdkNameRename } from "./sdkNames.js";
 export type ZiteSchemaField = {
     id: string;
     sdkName: string;
@@ -51,7 +52,33 @@ export type AirtableLock = {
     integrationId: string;
     tables: AirtableLockTable[];
 };
-export declare function generateAirtableTs(lock: AirtableLock): string | null;
+/**
+ * Make every table sdkName in the lock unique, so a duplicated lock can't emit
+ * a file that cannot compile (TS2300/TS2451) and that no app can edit or
+ * exclude.
+ *
+ * A contested name goes to NOBODY. The lock cannot say which table app code
+ * meant, and lock order is no oracle: a rename leaves the original owner
+ * first, while reordering or multi-base flattening can put the newcomer
+ * first. Guessing wrong would keep stale references compiling against the
+ * other table's data (the client is addressed by `tableId`, so the binding
+ * follows whichever table holds the name). With the bare name gone, a stale
+ * reference fails as an unresolved import instead: visible and fixable.
+ *
+ * Field sdkNames are left untouched. They are wire keys, resolved by the
+ * server from stored nameMappings that a generate-time rename can never
+ * update, so a renamed field would type-check yet read `undefined` and fail
+ * every write. Unlike tables, duplicates cannot form there: the producer
+ * seeds field allocation from the stored mappings.
+ *
+ * Names are assigned in declaration order, so an unchanged lock regenerates
+ * the identical file.
+ */
+export declare function normalizeAirtableLockNames(lock: AirtableLock): {
+    lock: AirtableLock;
+    renames: SdkNameRename[];
+};
+export declare function generateAirtableTs(inputLock: AirtableLock): string | null;
 export declare function generateBackendWrapperTs(envVarNames?: string[]): string;
 /**
  * Generate `.zite/integrations/email.ts` — the `Email` client for an app with

package/dist/cjs/sync/lib.js

@@ -4,6 +4,7 @@ exports.toSdkName = exports.toCamelCase = exports.toPascalCase = void 0;
 exports.generateSchema = generateSchema;
 exports.generateDbTs = generateDbTs;
 exports.generateApiTs = generateApiTs;
+exports.normalizeAirtableLockNames = normalizeAirtableLockNames;
 exports.generateAirtableTs = generateAirtableTs;
 exports.generateBackendWrapperTs = generateBackendWrapperTs;
 exports.generateEmailSdk = generateEmailSdk;
@@ -1054,9 +1055,71 @@ function airtableFieldJsdoc(field, table, lock) {
         return undefined;
     return parts.join(". ");
 }
-function generateAirtableTs(lock) {
-    if (lock.tables.length === 0)
+// A table client is a `const`, so only value-space bindings can collide with
+// one. `AirtableAttachment` is a type, and types and consts coexist.
+const RESERVED_AIRTABLE_NAMES = ["createAirtableClient"];
+/**
+ * Make every table sdkName in the lock unique, so a duplicated lock can't emit
+ * a file that cannot compile (TS2300/TS2451) and that no app can edit or
+ * exclude.
+ *
+ * A contested name goes to NOBODY. The lock cannot say which table app code
+ * meant, and lock order is no oracle: a rename leaves the original owner
+ * first, while reordering or multi-base flattening can put the newcomer
+ * first. Guessing wrong would keep stale references compiling against the
+ * other table's data (the client is addressed by `tableId`, so the binding
+ * follows whichever table holds the name). With the bare name gone, a stale
+ * reference fails as an unresolved import instead: visible and fixable.
+ *
+ * Field sdkNames are left untouched. They are wire keys, resolved by the
+ * server from stored nameMappings that a generate-time rename can never
+ * update, so a renamed field would type-check yet read `undefined` and fail
+ * every write. Unlike tables, duplicates cannot form there: the producer
+ * seeds field allocation from the stored mappings.
+ *
+ * Names are assigned in declaration order, so an unchanged lock regenerates
+ * the identical file.
+ */
+function normalizeAirtableLockNames(lock) {
+    const owners = new Map();
+    for (const table of lock.tables) {
+        owners.set(table.sdkName, (owners.get(table.sdkName) ?? 0) + 1);
+    }
+    const contested = [...owners.entries()]
+        .filter(([, count]) => count > 1)
+        .map(([name]) => name);
+    const tableNames = new sdkNames_js_1.SdkNameAllocator({
+        reserved: [...RESERVED_AIRTABLE_NAMES, ...contested],
+    });
+    // Sole owners claim their names before any contender is suffixed, so a
+    // contender can never displace a table legitimately named `GroupCalls2`.
+    const kept = lock.tables.map((table) => owners.get(table.sdkName) === 1 && tableNames.available(table.sdkName)
+        ? tableNames.allocate(table.sdkName)
+        : undefined);
+    const renames = [];
+    const tables = lock.tables.map((table, i) => {
+        const sdkName = kept[i] ?? tableNames.allocate(table.sdkName);
+        if (sdkName !== table.sdkName) {
+            renames.push({
+                kind: "table",
+                tableId: table.id,
+                from: table.sdkName,
+                to: sdkName,
+            });
+        }
+        return { ...table, sdkName };
+    });
+    return { lock: { ...lock, tables }, renames };
+}
+function generateAirtableTs(inputLock) {
+    if (inputLock.tables.length === 0)
         return null;
+    const { lock, renames } = normalizeAirtableLockNames(inputLock);
+    if (renames.length > 0) {
+        for (const line of (0, sdkNames_js_1.describeRenames)(renames)) {
+            console.warn(`[zitejs] SDK name conflict in zite.lock; the generated Airtable SDK uses: ${line}`);
+        }
+    }
     const lines = [
         "// Auto-generated by zitejs generate from zite.lock. Do not edit manually.",
         "// Airtable SDK — uses createAirtableClient from zitejs/runtime.",
@@ -1225,7 +1288,9 @@ function generateBackendWrapperTs(envVarNames = []) {
         "export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream extends boolean = false, TSchedule extends ZiteSchedule | undefined = undefined, TWebhook extends ZiteWebhook | undefined = undefined, TRawInput = TInput> {",
         "  description?: string;",
         "  inputSchema?: SchemaLike<TInput, TRawInput>;",
-        "  outputSchema?: SchemaLike<TOutput>;",
+        // Apps compile against this copy, not the base module's.
+        "  /** Documentation only. Never validated, and not an inference site for TOutput. */",
+        "  outputSchema?: SchemaLike<unknown>;",
         "  stream?: TStream;",
         "  authenticated?: boolean;",
         "  /** When set, the endpoint also fires on this cron schedule. It stays request-callable — declaring one widens `context`, so `context.user` must be null-checked. */",

package/dist/cjs/sync/lib.test.js

@@ -51,6 +51,173 @@ const schemaWithSelectOption = (label) => ({
         (0, vitest_1.expect)(out).toContain('"The \\"Premium\\" tier"');
     });
 });
+/** TS2300/TS2451, which `syntaxErrorsIn` can't see — a duplicate export parses fine. */
+const duplicateIdentifierErrorsIn = (source) => {
+    const AMBIENT = `declare module 'zitejs/runtime' {
+    export function createAirtableClient<T, TInput = T>(
+      integrationId: string,
+      className: string,
+      implicitParams: Record<string, unknown>,
+    ): unknown;
+  }`;
+    const sources = {
+        'ambient.d.ts': AMBIENT,
+        'airtable.ts': source,
+    };
+    const host = typescript_1.default.createCompilerHost({});
+    const original = host.getSourceFile.bind(host);
+    host.getSourceFile = (fileName, langVersion, onError, shouldCreate) => sources[fileName] !== undefined
+        ? typescript_1.default.createSourceFile(fileName, sources[fileName], langVersion, true)
+        : original(fileName, langVersion, onError, shouldCreate);
+    host.fileExists = f => sources[f] !== undefined || typescript_1.default.sys.fileExists(f);
+    host.readFile = f => sources[f] ?? typescript_1.default.sys.readFile(f);
+    const program = typescript_1.default.createProgram(Object.keys(sources), { strict: true, noEmit: true, skipLibCheck: true }, host);
+    return typescript_1.default
+        .getPreEmitDiagnostics(program)
+        .filter(d => d.code === 2300 || d.code === 2451)
+        .map(d => typescript_1.default.flattenDiagnosticMessageText(d.messageText, ' '));
+};
+(0, vitest_1.describe)('generateAirtableTs duplicate SDK names', () => {
+    // ZIT-5032: two tables both resolved to `GroupCalls`.
+    const collidingLock = (name) => ({
+        integrationId: 'airtable',
+        tables: [
+            {
+                id: 'tblV204b5ogVasPKc',
+                sdkName: name,
+                primaryFieldId: 'fld1',
+                fields: [
+                    { id: 'fld1', sdkName: 'title', type: 'singleLineText', name: 'Title' },
+                ],
+            },
+            {
+                id: 'tblt474V0WyNlrHX9',
+                sdkName: name,
+                primaryFieldId: 'fld2',
+                fields: [
+                    { id: 'fld2', sdkName: 'title', type: 'singleLineText', name: 'Title' },
+                ],
+            },
+        ],
+    });
+    (0, vitest_1.it)('compiles when two tables resolve to the same SDK name', () => {
+        (0, vitest_1.expect)(duplicateIdentifierErrorsIn((0, lib_js_1.generateAirtableTs)(collidingLock('GroupCalls')) ?? '')).toEqual([]);
+    });
+    // Lock order cannot say which table originally owned the name, and handing
+    // it to the wrong one would leave stale references compiling against the
+    // other table's data. Suffixing every contender turns them into unresolved
+    // imports instead.
+    (0, vitest_1.it)('gives a contested name to neither table', () => {
+        const out = (0, lib_js_1.generateAirtableTs)(collidingLock('GroupCalls')) ?? '';
+        (0, vitest_1.expect)(out).not.toContain('export const GroupCalls = ');
+        (0, vitest_1.expect)(out).toContain('export const GroupCalls2 = ');
+        (0, vitest_1.expect)(out).toContain('export const GroupCalls3 = ');
+    });
+    (0, vitest_1.it)('still addresses each table by its own id, so data access is unchanged', () => {
+        const out = (0, lib_js_1.generateAirtableTs)(collidingLock('GroupCalls')) ?? '';
+        (0, vitest_1.expect)(out).toContain("'GroupCalls2',\n  { tableId: 'tblV204b5ogVasPKc' }");
+        (0, vitest_1.expect)(out).toContain("'GroupCalls3',\n  { tableId: 'tblt474V0WyNlrHX9' }");
+    });
+    (0, vitest_1.it)('never displaces the legitimate owner of a suffixed name', () => {
+        const table = (id, sdkName) => ({
+            id,
+            sdkName,
+            primaryFieldId: 'fld1',
+            fields: [
+                { id: 'fld1', sdkName: 'title', type: 'singleLineText', name: 'Title' },
+            ],
+        });
+        const out = (0, lib_js_1.generateAirtableTs)({
+            integrationId: 'airtable',
+            tables: [
+                table('tblA', 'GroupCalls'),
+                table('tblB', 'GroupCalls'),
+                table('tblC', 'GroupCalls2'),
+            ],
+        }) ?? '';
+        (0, vitest_1.expect)(out).toContain("'GroupCalls2',\n  { tableId: 'tblC' }");
+        (0, vitest_1.expect)(out).toContain('export const GroupCalls3 = ');
+        (0, vitest_1.expect)(out).toContain('export const GroupCalls4 = ');
+        (0, vitest_1.expect)(out).not.toContain('export const GroupCalls = ');
+        (0, vitest_1.expect)(duplicateIdentifierErrorsIn(out)).toEqual([]);
+    });
+    (0, vitest_1.it)('does not rename anything when names are already unique', () => {
+        const out = (0, lib_js_1.generateAirtableTs)({
+            integrationId: 'airtable',
+            tables: [
+                {
+                    id: 'tbl1',
+                    sdkName: 'Calls',
+                    primaryFieldId: 'fld1',
+                    fields: [
+                        { id: 'fld1', sdkName: 'title', type: 'singleLineText', name: 'Title' },
+                    ],
+                },
+            ],
+        }) ?? '';
+        (0, vitest_1.expect)(out).toContain('export const Calls = ');
+        (0, vitest_1.expect)(out).not.toContain('Calls2');
+    });
+    // A field's sdkName is a wire key: the server resolves it from the stored
+    // nameMappings, which a generate-time rename can never update. A renamed
+    // field would type-check yet read `undefined` and fail every write, so
+    // fields are never renamed here.
+    (0, vitest_1.it)('leaves field names alone, even when they collide', () => {
+        const out = (0, lib_js_1.generateAirtableTs)({
+            integrationId: 'airtable',
+            tables: [
+                {
+                    id: 'tbl1',
+                    sdkName: 'Calls',
+                    primaryFieldId: 'fldA',
+                    fields: [
+                        { id: 'fldA', sdkName: 'notes', type: 'singleLineText', name: 'Notes' },
+                        { id: 'fldB', sdkName: 'notes', type: 'singleLineText', name: 'Notes copy' },
+                    ],
+                },
+            ],
+        }) ?? '';
+        (0, vitest_1.expect)(out).not.toContain('notes2');
+    });
+    (0, vitest_1.it)('still skips a field named `id` instead of renaming it', () => {
+        const out = (0, lib_js_1.generateAirtableTs)({
+            integrationId: 'airtable',
+            tables: [
+                {
+                    id: 'tbl1',
+                    sdkName: 'Calls',
+                    primaryFieldId: 'fldA',
+                    fields: [
+                        { id: 'fldA', sdkName: 'id', type: 'singleLineText', name: 'ID' },
+                        { id: 'fldB', sdkName: 'title', type: 'singleLineText', name: 'Title' },
+                    ],
+                },
+            ],
+        }) ?? '';
+        (0, vitest_1.expect)(out).not.toContain('id2');
+        (0, vitest_1.expect)(out).not.toContain('id?:');
+        // the record id, emitted by hand, stays the only `id`
+        (0, vitest_1.expect)(out).toContain('id: string;');
+    });
+    (0, vitest_1.it)('leaves a table named after the attachment type alone', () => {
+        const out = (0, lib_js_1.generateAirtableTs)({
+            integrationId: 'airtable',
+            tables: [
+                {
+                    id: 'tbl1',
+                    sdkName: 'AirtableAttachment',
+                    primaryFieldId: 'fld1',
+                    fields: [
+                        { id: 'fld1', sdkName: 'title', type: 'singleLineText', name: 'Title' },
+                    ],
+                },
+            ],
+        }) ?? '';
+        (0, vitest_1.expect)(duplicateIdentifierErrorsIn(out)).toEqual([]);
+        (0, vitest_1.expect)(out).toContain('export const AirtableAttachment = ');
+        (0, vitest_1.expect)(out).not.toContain('AirtableAttachment2');
+    });
+});
 (0, vitest_1.describe)('generateAirtableTs attachment type', () => {
     const lockWithAttachment = {
         integrationId: 'airtable',

package/dist/cjs/sync/sdkNames.d.ts

@@ -66,6 +66,33 @@ export interface SdkNameRename {
     from: string;
     to: string;
 }
+/**
+ * Unique identifiers within one namespace.
+ *
+ * `derive` names the extra keys an allocation also occupies. A table needs it:
+ * its sdkName becomes both a property on `zite` and, PascalCased, a pair of
+ * exported type declarations, so `orders` and `Orders` are distinct accessors
+ * that would emit `OrdersRecordType` twice.
+ */
+export declare class SdkNameAllocator {
+    private readonly taken;
+    private readonly reserved;
+    private readonly derive;
+    constructor(opts?: {
+        reserved?: readonly string[];
+        derive?: (name: string) => string[];
+    });
+    private keysFor;
+    private isFree;
+    /** Free right now, without claiming it. */
+    available(name: string): boolean;
+    private claim;
+    /**
+     * `name`, or the first `name2`, `name3`… that is free. Suffixes start at 2
+     * because that is what the name means: the second table called Notifications.
+     */
+    allocate(preferred: string): string;
+}
 /**
  * Existing sdkNames are preserved across syncs so user code keeps compiling,
  * but a schema written before the sanitizer stripped trailing symbols can carry

package/dist/cjs/sync/sdkNames.js

@@ -22,7 +22,7 @@
  * cannot compile.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RESERVED_FIELD_ACCESSORS = exports.RESERVED_IDENTIFIERS = exports.RESERVED_TABLE_ACCESSORS = void 0;
+exports.SdkNameAllocator = exports.RESERVED_FIELD_ACCESSORS = exports.RESERVED_IDENTIFIERS = exports.RESERVED_TABLE_ACCESSORS = void 0;
 exports.toPascalCase = toPascalCase;
 exports.toCamelCase = toCamelCase;
 exports.toSdkName = toSdkName;
@@ -146,6 +146,7 @@ class SdkNameAllocator {
         throw new Error(`Could not allocate a unique SDK name for "${preferred}" after ${MAX_SUFFIX_ATTEMPTS} attempts`);
     }
 }
+exports.SdkNameAllocator = SdkNameAllocator;
 /**
  * Existing sdkNames are preserved across syncs so user code keeps compiling,
  * but a schema written before the sanitizer stripped trailing symbols can carry

package/dist/esm/backend/index.d.ts

@@ -61,7 +61,13 @@ export type ZiteStreamInterface = {
 export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream extends boolean = false, TSchedule extends ZiteSchedule | undefined = undefined, TWebhook extends ZiteWebhook | undefined = undefined, TRawInput = TInput> {
     description?: string;
     inputSchema?: SchemaLike<TInput, TRawInput>;
-    outputSchema?: SchemaLike<TOutput>;
+    /**
+     * Documentation only — never validated, and `unknown` so it cannot compete
+     * with `execute` for `TOutput`. A nullable column reads as `T | undefined`
+     * while its schema says `.nullable()`; making both inference sites failed the
+     * build on the difference.
+     */
+    outputSchema?: SchemaLike<unknown>;
     stream?: TStream;
     authenticated?: boolean;
     /**

package/dist/esm/runtime/filterConditionTypes.test-d.d.ts

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

package/dist/esm/runtime/filterConditionTypes.test-d.js

@@ -0,0 +1,38 @@
+import { describe, it, expectTypeOf } from "vitest";
+describe("FilterCondition in/notIn", () => {
+    // The idiom that regressed. `.filter(Boolean)` does not narrow in TypeScript,
+    // so this is `(string | undefined)[]` — compiling at all is the assertion.
+    it("accepts .map(…).filter(Boolean) over a nullable column", () => {
+        const keys = routes.map((r) => r.compositeRouteKey).filter(Boolean);
+        expectTypeOf(keys).toEqualTypeOf();
+        expectTypeOf().toMatchTypeOf();
+        expectTypeOf().toMatchTypeOf();
+    });
+    // One array of a union, not a union of arrays.
+    it("collapses a nullable column to a single array type", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    // The unwrapping that the conditional exists for: an array-valued column is
+    // filtered by its ELEMENT type, not by arrays of arrays.
+    it("still unwraps an array-valued column to its element type", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    it("leaves a plain scalar column alone", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+});
+describe("RecordFilters", () => {
+    // Through the keyed wrapper, which is how app code actually reaches it.
+    it("accepts the idiom on a nullable key", () => {
+        const filters = {
+            compositeRouteKey: {
+                in: routes.map((r) => r.compositeRouteKey).filter(Boolean),
+            },
+        };
+        expectTypeOf(filters).toMatchTypeOf();
+    });
+    it("accepts an element-typed `in` on an array column", () => {
+        const filters = { tags: { in: ["urgent"] } };
+        expectTypeOf(filters).toMatchTypeOf();
+    });
+});

package/dist/esm/runtime/index.d.ts

@@ -8,6 +8,11 @@
  * the operands buys little while breaking real migrated code: dates are ISO
  * strings here but 1.0 accepted `number | Date` on every comparison, and
  * `contains` was `any`.
+ *
+ * On `in`/`notIn` the `[]` sits OUTSIDE the conditional. A naked `V`
+ * distributes, so a nullable column produced `string[] | undefined[]` — two
+ * separate array types, neither of which accepts the `(string | undefined)[]`
+ * that `.map(…).filter(Boolean)` yields.
  */
 export type FilterCondition<V> = {
     /** Substring match (text fields) or "has any of these" (linked records). */
@@ -15,9 +20,9 @@ export type FilterCondition<V> = {
     /** Not equal, or — against `null` — "is set". */
     not?: V | null;
     /** An empty array matches NOTHING — the SDK's filters convert to the nested format, where `in: []` is "is one of nothing". */
-    in?: V extends Array<infer E> ? E[] : V[];
+    in?: (V extends Array<infer E> ? E : V)[];
     /** An empty array applies no filter at all — "is not one of nothing" is always true. */
-    notIn?: V extends Array<infer E> ? E[] : V[];
+    notIn?: (V extends Array<infer E> ? E : V)[];
     lt?: V | number | Date;
     lte?: V | number | Date;
     gt?: V | number | Date;

package/dist/esm/sync/lib.d.ts

@@ -1,5 +1,6 @@
 import type { PublicFieldDefinition } from "../types/fields.js";
 import type { Database } from "../types/tables.js";
+import { type SdkNameRename } from "./sdkNames.js";
 export type ZiteSchemaField = {
     id: string;
     sdkName: string;
@@ -51,7 +52,33 @@ export type AirtableLock = {
     integrationId: string;
     tables: AirtableLockTable[];
 };
-export declare function generateAirtableTs(lock: AirtableLock): string | null;
+/**
+ * Make every table sdkName in the lock unique, so a duplicated lock can't emit
+ * a file that cannot compile (TS2300/TS2451) and that no app can edit or
+ * exclude.
+ *
+ * A contested name goes to NOBODY. The lock cannot say which table app code
+ * meant, and lock order is no oracle: a rename leaves the original owner
+ * first, while reordering or multi-base flattening can put the newcomer
+ * first. Guessing wrong would keep stale references compiling against the
+ * other table's data (the client is addressed by `tableId`, so the binding
+ * follows whichever table holds the name). With the bare name gone, a stale
+ * reference fails as an unresolved import instead: visible and fixable.
+ *
+ * Field sdkNames are left untouched. They are wire keys, resolved by the
+ * server from stored nameMappings that a generate-time rename can never
+ * update, so a renamed field would type-check yet read `undefined` and fail
+ * every write. Unlike tables, duplicates cannot form there: the producer
+ * seeds field allocation from the stored mappings.
+ *
+ * Names are assigned in declaration order, so an unchanged lock regenerates
+ * the identical file.
+ */
+export declare function normalizeAirtableLockNames(lock: AirtableLock): {
+    lock: AirtableLock;
+    renames: SdkNameRename[];
+};
+export declare function generateAirtableTs(inputLock: AirtableLock): string | null;
 export declare function generateBackendWrapperTs(envVarNames?: string[]): string;
 /**
  * Generate `.zite/integrations/email.ts` — the `Email` client for an app with

package/dist/esm/sync/lib.js

@@ -1,5 +1,5 @@
 import { parse } from "@babel/parser";
-import { allocateSchemaNames, describeRenames, keepValidSdkName, normalizeSchemaNames, toCamelCase, toPascalCase, toSdkName, } from "./sdkNames.js";
+import { allocateSchemaNames, describeRenames, keepValidSdkName, normalizeSchemaNames, SdkNameAllocator, toCamelCase, toPascalCase, toSdkName, } from "./sdkNames.js";
 const AUTH_USERS_TABLE_ID = "zite_user";
 /**
  * What a field's value looks like when a record is READ back.
@@ -1042,9 +1042,71 @@ function airtableFieldJsdoc(field, table, lock) {
         return undefined;
     return parts.join(". ");
 }
-export function generateAirtableTs(lock) {
-    if (lock.tables.length === 0)
+// A table client is a `const`, so only value-space bindings can collide with
+// one. `AirtableAttachment` is a type, and types and consts coexist.
+const RESERVED_AIRTABLE_NAMES = ["createAirtableClient"];
+/**
+ * Make every table sdkName in the lock unique, so a duplicated lock can't emit
+ * a file that cannot compile (TS2300/TS2451) and that no app can edit or
+ * exclude.
+ *
+ * A contested name goes to NOBODY. The lock cannot say which table app code
+ * meant, and lock order is no oracle: a rename leaves the original owner
+ * first, while reordering or multi-base flattening can put the newcomer
+ * first. Guessing wrong would keep stale references compiling against the
+ * other table's data (the client is addressed by `tableId`, so the binding
+ * follows whichever table holds the name). With the bare name gone, a stale
+ * reference fails as an unresolved import instead: visible and fixable.
+ *
+ * Field sdkNames are left untouched. They are wire keys, resolved by the
+ * server from stored nameMappings that a generate-time rename can never
+ * update, so a renamed field would type-check yet read `undefined` and fail
+ * every write. Unlike tables, duplicates cannot form there: the producer
+ * seeds field allocation from the stored mappings.
+ *
+ * Names are assigned in declaration order, so an unchanged lock regenerates
+ * the identical file.
+ */
+export function normalizeAirtableLockNames(lock) {
+    const owners = new Map();
+    for (const table of lock.tables) {
+        owners.set(table.sdkName, (owners.get(table.sdkName) ?? 0) + 1);
+    }
+    const contested = [...owners.entries()]
+        .filter(([, count]) => count > 1)
+        .map(([name]) => name);
+    const tableNames = new SdkNameAllocator({
+        reserved: [...RESERVED_AIRTABLE_NAMES, ...contested],
+    });
+    // Sole owners claim their names before any contender is suffixed, so a
+    // contender can never displace a table legitimately named `GroupCalls2`.
+    const kept = lock.tables.map((table) => owners.get(table.sdkName) === 1 && tableNames.available(table.sdkName)
+        ? tableNames.allocate(table.sdkName)
+        : undefined);
+    const renames = [];
+    const tables = lock.tables.map((table, i) => {
+        const sdkName = kept[i] ?? tableNames.allocate(table.sdkName);
+        if (sdkName !== table.sdkName) {
+            renames.push({
+                kind: "table",
+                tableId: table.id,
+                from: table.sdkName,
+                to: sdkName,
+            });
+        }
+        return { ...table, sdkName };
+    });
+    return { lock: { ...lock, tables }, renames };
+}
+export function generateAirtableTs(inputLock) {
+    if (inputLock.tables.length === 0)
         return null;
+    const { lock, renames } = normalizeAirtableLockNames(inputLock);
+    if (renames.length > 0) {
+        for (const line of describeRenames(renames)) {
+            console.warn(`[zitejs] SDK name conflict in zite.lock; the generated Airtable SDK uses: ${line}`);
+        }
+    }
     const lines = [
         "// Auto-generated by zitejs generate from zite.lock. Do not edit manually.",
         "// Airtable SDK — uses createAirtableClient from zitejs/runtime.",
@@ -1213,7 +1275,9 @@ export function generateBackendWrapperTs(envVarNames = []) {
         "export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream extends boolean = false, TSchedule extends ZiteSchedule | undefined = undefined, TWebhook extends ZiteWebhook | undefined = undefined, TRawInput = TInput> {",
         "  description?: string;",
         "  inputSchema?: SchemaLike<TInput, TRawInput>;",
-        "  outputSchema?: SchemaLike<TOutput>;",
+        // Apps compile against this copy, not the base module's.
+        "  /** Documentation only. Never validated, and not an inference site for TOutput. */",
+        "  outputSchema?: SchemaLike<unknown>;",
         "  stream?: TStream;",
         "  authenticated?: boolean;",
         "  /** When set, the endpoint also fires on this cron schedule. It stays request-callable — declaring one widens `context`, so `context.user` must be null-checked. */",

package/dist/esm/sync/lib.test.js

@@ -46,6 +46,173 @@ describe('generateDbTs select option literals', () => {
         expect(out).toContain('"The \\"Premium\\" tier"');
     });
 });
+/** TS2300/TS2451, which `syntaxErrorsIn` can't see — a duplicate export parses fine. */
+const duplicateIdentifierErrorsIn = (source) => {
+    const AMBIENT = `declare module 'zitejs/runtime' {
+    export function createAirtableClient<T, TInput = T>(
+      integrationId: string,
+      className: string,
+      implicitParams: Record<string, unknown>,
+    ): unknown;
+  }`;
+    const sources = {
+        'ambient.d.ts': AMBIENT,
+        'airtable.ts': source,
+    };
+    const host = ts.createCompilerHost({});
+    const original = host.getSourceFile.bind(host);
+    host.getSourceFile = (fileName, langVersion, onError, shouldCreate) => sources[fileName] !== undefined
+        ? ts.createSourceFile(fileName, sources[fileName], langVersion, true)
+        : original(fileName, langVersion, onError, shouldCreate);
+    host.fileExists = f => sources[f] !== undefined || ts.sys.fileExists(f);
+    host.readFile = f => sources[f] ?? ts.sys.readFile(f);
+    const program = ts.createProgram(Object.keys(sources), { strict: true, noEmit: true, skipLibCheck: true }, host);
+    return ts
+        .getPreEmitDiagnostics(program)
+        .filter(d => d.code === 2300 || d.code === 2451)
+        .map(d => ts.flattenDiagnosticMessageText(d.messageText, ' '));
+};
+describe('generateAirtableTs duplicate SDK names', () => {
+    // ZIT-5032: two tables both resolved to `GroupCalls`.
+    const collidingLock = (name) => ({
+        integrationId: 'airtable',
+        tables: [
+            {
+                id: 'tblV204b5ogVasPKc',
+                sdkName: name,
+                primaryFieldId: 'fld1',
+                fields: [
+                    { id: 'fld1', sdkName: 'title', type: 'singleLineText', name: 'Title' },
+                ],
+            },
+            {
+                id: 'tblt474V0WyNlrHX9',
+                sdkName: name,
+                primaryFieldId: 'fld2',
+                fields: [
+                    { id: 'fld2', sdkName: 'title', type: 'singleLineText', name: 'Title' },
+                ],
+            },
+        ],
+    });
+    it('compiles when two tables resolve to the same SDK name', () => {
+        expect(duplicateIdentifierErrorsIn(generateAirtableTs(collidingLock('GroupCalls')) ?? '')).toEqual([]);
+    });
+    // Lock order cannot say which table originally owned the name, and handing
+    // it to the wrong one would leave stale references compiling against the
+    // other table's data. Suffixing every contender turns them into unresolved
+    // imports instead.
+    it('gives a contested name to neither table', () => {
+        const out = generateAirtableTs(collidingLock('GroupCalls')) ?? '';
+        expect(out).not.toContain('export const GroupCalls = ');
+        expect(out).toContain('export const GroupCalls2 = ');
+        expect(out).toContain('export const GroupCalls3 = ');
+    });
+    it('still addresses each table by its own id, so data access is unchanged', () => {
+        const out = generateAirtableTs(collidingLock('GroupCalls')) ?? '';
+        expect(out).toContain("'GroupCalls2',\n  { tableId: 'tblV204b5ogVasPKc' }");
+        expect(out).toContain("'GroupCalls3',\n  { tableId: 'tblt474V0WyNlrHX9' }");
+    });
+    it('never displaces the legitimate owner of a suffixed name', () => {
+        const table = (id, sdkName) => ({
+            id,
+            sdkName,
+            primaryFieldId: 'fld1',
+            fields: [
+                { id: 'fld1', sdkName: 'title', type: 'singleLineText', name: 'Title' },
+            ],
+        });
+        const out = generateAirtableTs({
+            integrationId: 'airtable',
+            tables: [
+                table('tblA', 'GroupCalls'),
+                table('tblB', 'GroupCalls'),
+                table('tblC', 'GroupCalls2'),
+            ],
+        }) ?? '';
+        expect(out).toContain("'GroupCalls2',\n  { tableId: 'tblC' }");
+        expect(out).toContain('export const GroupCalls3 = ');
+        expect(out).toContain('export const GroupCalls4 = ');
+        expect(out).not.toContain('export const GroupCalls = ');
+        expect(duplicateIdentifierErrorsIn(out)).toEqual([]);
+    });
+    it('does not rename anything when names are already unique', () => {
+        const out = generateAirtableTs({
+            integrationId: 'airtable',
+            tables: [
+                {
+                    id: 'tbl1',
+                    sdkName: 'Calls',
+                    primaryFieldId: 'fld1',
+                    fields: [
+                        { id: 'fld1', sdkName: 'title', type: 'singleLineText', name: 'Title' },
+                    ],
+                },
+            ],
+        }) ?? '';
+        expect(out).toContain('export const Calls = ');
+        expect(out).not.toContain('Calls2');
+    });
+    // A field's sdkName is a wire key: the server resolves it from the stored
+    // nameMappings, which a generate-time rename can never update. A renamed
+    // field would type-check yet read `undefined` and fail every write, so
+    // fields are never renamed here.
+    it('leaves field names alone, even when they collide', () => {
+        const out = generateAirtableTs({
+            integrationId: 'airtable',
+            tables: [
+                {
+                    id: 'tbl1',
+                    sdkName: 'Calls',
+                    primaryFieldId: 'fldA',
+                    fields: [
+                        { id: 'fldA', sdkName: 'notes', type: 'singleLineText', name: 'Notes' },
+                        { id: 'fldB', sdkName: 'notes', type: 'singleLineText', name: 'Notes copy' },
+                    ],
+                },
+            ],
+        }) ?? '';
+        expect(out).not.toContain('notes2');
+    });
+    it('still skips a field named `id` instead of renaming it', () => {
+        const out = generateAirtableTs({
+            integrationId: 'airtable',
+            tables: [
+                {
+                    id: 'tbl1',
+                    sdkName: 'Calls',
+                    primaryFieldId: 'fldA',
+                    fields: [
+                        { id: 'fldA', sdkName: 'id', type: 'singleLineText', name: 'ID' },
+                        { id: 'fldB', sdkName: 'title', type: 'singleLineText', name: 'Title' },
+                    ],
+                },
+            ],
+        }) ?? '';
+        expect(out).not.toContain('id2');
+        expect(out).not.toContain('id?:');
+        // the record id, emitted by hand, stays the only `id`
+        expect(out).toContain('id: string;');
+    });
+    it('leaves a table named after the attachment type alone', () => {
+        const out = generateAirtableTs({
+            integrationId: 'airtable',
+            tables: [
+                {
+                    id: 'tbl1',
+                    sdkName: 'AirtableAttachment',
+                    primaryFieldId: 'fld1',
+                    fields: [
+                        { id: 'fld1', sdkName: 'title', type: 'singleLineText', name: 'Title' },
+                    ],
+                },
+            ],
+        }) ?? '';
+        expect(duplicateIdentifierErrorsIn(out)).toEqual([]);
+        expect(out).toContain('export const AirtableAttachment = ');
+        expect(out).not.toContain('AirtableAttachment2');
+    });
+});
 describe('generateAirtableTs attachment type', () => {
     const lockWithAttachment = {
         integrationId: 'airtable',

package/dist/esm/sync/sdkNames.d.ts

@@ -66,6 +66,33 @@ export interface SdkNameRename {
     from: string;
     to: string;
 }
+/**
+ * Unique identifiers within one namespace.
+ *
+ * `derive` names the extra keys an allocation also occupies. A table needs it:
+ * its sdkName becomes both a property on `zite` and, PascalCased, a pair of
+ * exported type declarations, so `orders` and `Orders` are distinct accessors
+ * that would emit `OrdersRecordType` twice.
+ */
+export declare class SdkNameAllocator {
+    private readonly taken;
+    private readonly reserved;
+    private readonly derive;
+    constructor(opts?: {
+        reserved?: readonly string[];
+        derive?: (name: string) => string[];
+    });
+    private keysFor;
+    private isFree;
+    /** Free right now, without claiming it. */
+    available(name: string): boolean;
+    private claim;
+    /**
+     * `name`, or the first `name2`, `name3`… that is free. Suffixes start at 2
+     * because that is what the name means: the second table called Notifications.
+     */
+    allocate(preferred: string): string;
+}
 /**
  * Existing sdkNames are preserved across syncs so user code keeps compiling,
  * but a schema written before the sanitizer stripped trailing symbols can carry

package/dist/esm/sync/sdkNames.js

@@ -91,7 +91,7 @@ const MAX_SUFFIX_ATTEMPTS = 10_000;
  * exported type declarations, so `orders` and `Orders` are distinct accessors
  * that would emit `OrdersRecordType` twice.
  */
-class SdkNameAllocator {
+export class SdkNameAllocator {
     taken = new Set();
     reserved;
     derive;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zitejs",
-  "version": "0.9.109",
+  "version": "0.9.111",
   "description": "The Zite framework — build apps on Zite Database",
   "type": "module",
   "main": "./dist/cjs/index.js",