@peers-app/peers-sdk 0.26.6 → 0.27.0

package/dist/data/orm/sql.data-source.test.js

@@ -32,6 +32,12 @@ class DBHarness {
         const result = await this.db.prepare(sql).run(params);
         return { changes: result.changes };
     }
+    execSync(sql, params = []) {
+        return this.db.prepare(sql).run(params);
+    }
+    getSync(sql, params = []) {
+        return this.db.prepare(sql).get(params);
+    }
     async close() {
         this._db?.close();
         this._db = null;
@@ -431,6 +437,142 @@ describe("table", () => {
             await ArraysTable.db.close();
         });
     });
+    describe("when a field is empty", () => {
+        const tableType = {
+            name: "test_table_empty_values",
+            description: "Empty values",
+            primaryKeyName: "rowId",
+            fields: [
+                { name: "rowId", type: field_type_1.FieldType.id },
+                { name: "title", type: field_type_1.FieldType.string },
+                { name: "note", type: field_type_1.FieldType.string, optional: true },
+                { name: "count", type: field_type_1.FieldType.number, optional: true },
+                { name: "when", type: field_type_1.FieldType.Date, optional: true },
+                {
+                    name: "detail",
+                    type: field_type_1.FieldType.object,
+                    optional: true,
+                    fields: [
+                        { name: "city", type: field_type_1.FieldType.string },
+                        { name: "zip", type: field_type_1.FieldType.string, optional: true },
+                    ],
+                },
+                { name: "tags", type: field_type_1.FieldType.string, isArray: true, optional: true },
+                { name: "rank", type: field_type_1.FieldType.number, defaultValue: 5 },
+                { name: "priority", type: field_type_1.FieldType.number, optional: true, defaultValue: 2 },
+            ],
+        };
+        const EmptyTable = new sql_data_source_1.SQLDataSource(db, tableType);
+        const empty = { note: null, count: undefined, when: null, tags: null };
+        beforeAll(async () => {
+            await EmptyTable.dropTableIfExists();
+        });
+        it("leaves out null and undefined optional fields and reads them back unset", async () => {
+            const detail = { city: "Austin", zip: null };
+            const row = { rowId: (0, utils_1.newid)(), title: "a", ...empty, detail };
+            const expected = {
+                rowId: row.rowId,
+                title: "a",
+                detail: { city: "Austin" },
+                rank: 5,
+                priority: 2,
+            };
+            expect(await EmptyTable.save(row)).toEqual(expected);
+            expect(row).not.toHaveProperty("count");
+            expect(await EmptyTable.get(row.rowId)).toEqual(expected);
+            const stored = await db.get(`SELECT * FROM "${EmptyTable.tableName}" WHERE rowId = ?`, [
+                row.rowId,
+            ]);
+            expect(stored.note).toBeNull();
+            // The caller's nested object is left as it was.
+            expect(detail).toEqual({ city: "Austin", zip: null });
+        });
+        it("clears a field saved empty, and gives an empty field with a default its default", async () => {
+            const row = { rowId: (0, utils_1.newid)(), title: "a", note: "set", rank: 7 };
+            await EmptyTable.save(row);
+            expect(await EmptyTable.get(row.rowId)).toEqual(row);
+            expect(await EmptyTable.save({ ...row, note: null, rank: null })).toEqual({
+                rowId: row.rowId,
+                title: "a",
+                rank: 5,
+                priority: 2,
+            });
+            expect(await EmptyTable.get(row.rowId)).toEqual({
+                rowId: row.rowId,
+                title: "a",
+                rank: 5,
+                priority: 2,
+            });
+        });
+        it("does the same in synchronous inserts and updates", async () => {
+            await EmptyTable.initTable();
+            const row = { rowId: (0, utils_1.newid)(), title: "a", note: "set", rank: 7 };
+            db.db.transaction(() => EmptyTable.saveSync({ ...row, note: null }))();
+            expect(await EmptyTable.get(row.rowId)).toEqual({
+                rowId: row.rowId,
+                title: "a",
+                rank: 7,
+                priority: 2,
+            });
+            db.db.transaction(() => EmptyTable.saveSync({ ...row, rank: null }))();
+            expect(await EmptyTable.get(row.rowId)).toEqual({ ...row, rank: 5, priority: 2 });
+        });
+        it.each([
+            null,
+            undefined,
+            "missing",
+        ])("resets an optional default for %s in either update path", async (emptyValue) => {
+            const row = { rowId: (0, utils_1.newid)(), title: "a", rank: 7, priority: 9 };
+            await EmptyTable.save(row);
+            const cleared = {
+                rowId: row.rowId,
+                title: "a",
+                rank: 7,
+                ...(emptyValue === "missing" ? {} : { priority: emptyValue }),
+            };
+            const expected = { rowId: row.rowId, title: "a", rank: 7, priority: 2 };
+            expect(await EmptyTable.update({ ...cleared })).toStrictEqual(expected);
+            expect(await EmptyTable.get(row.rowId)).toEqual(expected);
+            await EmptyTable.update(row);
+            expect(EmptyTable.updateSync({ ...cleared })).toStrictEqual(expected);
+            expect(await EmptyTable.get(row.rowId)).toEqual(expected);
+        });
+        it("still refuses an empty required field", async () => {
+            const row = { rowId: (0, utils_1.newid)(), title: null };
+            await expect(EmptyTable.save(row)).rejects.toThrow(/Expected string/);
+            expect(() => EmptyTable.saveSync(row)).toThrow(/Expected string/);
+            expect(await EmptyTable.get(row.rowId)).toBeUndefined();
+        });
+        afterAll(async () => {
+            await EmptyTable.dropTableIfExists();
+            await EmptyTable.db.close();
+        });
+    });
+    it("keeps legacy nullable enum defaults working without changing their field IR", async () => {
+        // FrameMembers.role uses this schema; legacy schemaToFields must remain unchanged.
+        const schema = zod_1.z.object({
+            rowId: zod_types_1.zodPeerId,
+            role: zod_1.z.enum(["observation", "value"]).nullable().default(null),
+        });
+        const fields = (0, types_1.schemaToFields)(schema);
+        expect(fields[1]).toEqual({
+            name: "role",
+            type: field_type_1.FieldType.any,
+            defaultValue: expect.any(Function),
+        });
+        const source = new sql_data_source_1.SQLDataSource(db, {
+            name: "legacy_empty_default",
+            description: "Legacy nullable enum default.",
+            primaryKeyName: "rowId",
+            fields,
+        });
+        const row = { rowId: (0, utils_1.newid)(), role: null };
+        expect(await source.insert(row)).toEqual(row);
+        await source.update({ rowId: row.rowId, role: "value" });
+        expect(await source.update({ rowId: row.rowId, role: null })).toEqual(row);
+        expect(source.updateSync({ rowId: row.rowId, role: null })).toEqual(row);
+        await source.dropTableIfExists();
+    });
 });
 describe("Tools additive catalog migration", () => {
     test("catalog readiness retries failed SQLite schema initialization on the same source", async () => {

package/dist/data/orm/table-container.js

@@ -8,17 +8,13 @@ const table_1 = require("./table");
 const table_definitions_system_1 = require("./table-definitions.system");
 const types_1 = require("./types");
 /**
- * Normalize metaData for structural comparison by stripping fields that can differ
- * between in-memory and DB-serialized representations without representing a real schema change.
- * Specifically, `defaultValue` contains functions that the DB layer serializes as "__FUNCTION ..."
- * strings (via serial-json.ts toJSON), causing false hash mismatches on every load.
- * `defaultValue` is not part of the SQLite column schema so excluding it is semantically correct.
+ * Normalize metaData for structural comparison by keeping only the field keys that represent a
+ * schema change ({@link comparableTableFields}). In particular, `defaultValue` contains functions
+ * that the DB layer serializes as "__FUNCTION ..." strings (via serial-json.ts toJSON), which
+ * would cause false hash mismatches on every load; it is not part of the SQLite column schema.
  */
 function normalizeMetaDataForComparison(metaData) {
-    return {
-        ...metaData,
-        fields: metaData.fields.map(({ defaultValue: _omit, ...rest }) => rest),
-    };
+    return { ...metaData, fields: (0, types_1.comparableTableFields)(metaData.fields) };
 }
 /**
  * Compare two table definition versions and decide whether to update.
@@ -319,6 +315,10 @@ class TableContainer {
             }
         }
         for (const [tableName, fallbackDefinition] of Object.entries(this.fallbackDefinitions)) {
+            // A package may supersede a fallback's storage policy when it registers a newer schema.
+            // Match table resolution: a full definition takes precedence over its stale fallback.
+            if (this.tableDefinitions[tableName] || table_definitions_system_1.systemTableDefinitions[tableName])
+                continue;
             if (fallbackDefinition.metaData.localOnly && !names.includes(tableName)) {
                 names.push(tableName);
             }

package/dist/data/orm/table-container.test.js

@@ -52,6 +52,36 @@ describe("checkVersionedUpdate", () => {
         expect((0, table_container_1.checkVersionedUpdate)(100, 50, metaA, metaA)).toBe("skip");
         expect((0, table_container_1.checkVersionedUpdate)(100, 50, metaA, metaB)).toBe("skip");
     });
+    it("ignores richer field metadata at the same version but still reports column changes", () => {
+        const report = jest.spyOn(console, "error").mockImplementation(() => { });
+        try {
+            const existing = {
+                ...metaA,
+                fields: [{ name: "detail", type: field_type_1.FieldType.object }],
+            };
+            const enriched = {
+                ...existing,
+                fields: [
+                    {
+                        type: field_type_1.FieldType.object,
+                        name: "detail",
+                        fields: [{ name: "mode", type: field_type_1.FieldType.string, enumValues: ["on", "off"] }],
+                        future: "ignored",
+                    },
+                ],
+            };
+            expect((0, table_container_1.checkVersionedUpdate)(1, 1, existing, enriched)).toBe("skip");
+            expect(report).not.toHaveBeenCalled();
+            expect((0, table_container_1.checkVersionedUpdate)(1, 1, existing, {
+                ...enriched,
+                fields: [{ name: "detail", type: field_type_1.FieldType.string }],
+            })).toBe("skip");
+            expect(report).toHaveBeenCalledTimes(1);
+        }
+        finally {
+            report.mockRestore();
+        }
+    });
 });
 // --- Tiered table instance tests ---
 // Custom Table subclass for testing
@@ -226,4 +256,18 @@ describe("getLocalOnlyTableNames", () => {
         const localOnlyNames = container.getLocalOnlyTableNames();
         expect(localOnlyNames.filter((name) => name === defRecord.name)).toHaveLength(1);
     });
+    it("lets a synced code definition supersede a local-only fallback", () => {
+        const { container, testMetaData, testSchema, defRecord } = createTestHarness();
+        container.registerFromTableDefinitionRecord({
+            ...defRecord,
+            metaData: { ...testMetaData, localOnly: true, versionNumber: 1 },
+            versionNumber: 1,
+        });
+        expect(container.getLocalOnlyTableNames()).toContain(defRecord.name);
+        container.registerTableDefinition({
+            metaData: { ...testMetaData, versionNumber: 2 },
+            schema: testSchema,
+        });
+        expect(container.getLocalOnlyTableNames()).not.toContain(defRecord.name);
+    });
 });

package/dist/data/orm/types.d.ts

@@ -26,12 +26,52 @@ export interface ITableMetaData {
     versionNumber?: number;
 }
 /**
- * Convert field metadata to the runtime Zod schema used by table validation.
+ * Convert field metadata to the runtime Zod schema the Runtime validates with: table rows and
+ * tool arguments.
+ *
+ * It checks types only: `type`, `isArray`, and `optional`. An object field accepts any object
+ * and keeps its keys; nested `fields` and `enumValues` aren't checked, so a row or call from a
+ * package built against a newer shape isn't refused. {@link fieldsToShapeSchema} builds the full
+ * shape. An optional field refuses `null`: remove empty fields first with
+ * {@link withoutEmptyFields}.
  *
  * @param fields Serializable field definitions.
  * @param codeSchema Optional author schema whose refinements are intersected.
  */
 export declare function fieldsToSchema(fields: IField[], codeSchema?: z.AnyZodObject): z.AnyZodObject;
+/**
+ * Convert field metadata to a Zod schema with every shape the IR carries: nested object
+ * `fields` and `enumValues`, as well as types. Objects keep keys their `fields` don't list. For
+ * describing a tool's arguments to an assistant's model; the Runtime validates with
+ * {@link fieldsToSchema}.
+ *
+ * @param fields Serializable field definitions.
+ */
+export declare function fieldsToShapeSchema(fields: IField[]): z.AnyZodObject;
+/**
+ * `value` without its empty fields, as the Runtime stores and delivers it: an optional field
+ * that is `null` or `undefined` is left out, in nested object `fields` too (including each
+ * object in an array). An empty field with a default is removed so parsing fills the default.
+ * A required field without a default keeps its value, so validation still refuses an empty
+ * one. Values inside an object or array that `fields` doesn't describe are left as they are.
+ * Returns `value` itself when nothing is removed, and a copy otherwise; `value` is never changed.
+ *
+ * @param fields The fields describing `value`.
+ * @param value A row, a tool's arguments, or an event payload.
+ */
+export declare function withoutEmptyFields<T>(fields: IField[], value: T): T;
+/**
+ * The fields of a table definition as table-definition comparisons see them: name, description,
+ * type, optional, isArray, and subType, in a fixed order. Left out: `defaultValue` (the database
+ * stores a function default as a string), the keys the IR gained later (`fields` and
+ * `enumValues`), and keys this SDK doesn't know, so rebuilding a package with a newer SDK doesn't
+ * make the same table version look different. A device keeps the definition it stored until the
+ * table's `versionNumber` changes.
+ *
+ * @internal
+ * @param fields A table definition's fields.
+ */
+export declare function comparableTableFields(fields: IField[]): Partial<IField>[];
 /**
  * Convert a Zod object schema to serializable field metadata.
  *

package/dist/data/orm/types.js

@@ -1,44 +1,83 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fieldsToSchema = fieldsToSchema;
+exports.fieldsToShapeSchema = fieldsToShapeSchema;
+exports.withoutEmptyFields = withoutEmptyFields;
+exports.comparableTableFields = comparableTableFields;
 exports.schemaToFields = schemaToFields;
 const zod_1 = require("zod");
 const field_type_1 = require("../../types/field-type");
 const utils_1 = require("../../utils");
 /**
- * Convert field metadata to the runtime Zod schema used by table validation.
+ * Convert field metadata to the runtime Zod schema the Runtime validates with: table rows and
+ * tool arguments.
+ *
+ * It checks types only: `type`, `isArray`, and `optional`. An object field accepts any object
+ * and keeps its keys; nested `fields` and `enumValues` aren't checked, so a row or call from a
+ * package built against a newer shape isn't refused. {@link fieldsToShapeSchema} builds the full
+ * shape. An optional field refuses `null`: remove empty fields first with
+ * {@link withoutEmptyFields}.
  *
  * @param fields Serializable field definitions.
  * @param codeSchema Optional author schema whose refinements are intersected.
  */
 function fieldsToSchema(fields, codeSchema) {
-    let argsSchema = zod_1.z.object({});
-    for (const argSchema of fields) {
-        const { name, description, type, isArray, defaultValue, optional } = argSchema;
-        let propertyType;
-        switch (type) {
-            case "id":
-                propertyType = zod_1.z.string().refine((id) => (0, utils_1.isid)(id), { message: "Invalid id" });
-                propertyType._def._fieldType = field_type_1.FieldType.id;
-                break;
-            case "string":
-                propertyType = zod_1.z.string();
-                break;
-            case "number":
-                propertyType = zod_1.z.number();
-                break;
-            case "boolean":
-                propertyType = zod_1.z.boolean();
-                break;
-            case "Date":
-                propertyType = zod_1.z.date();
-                break;
-            case "object":
-                propertyType = zod_1.z.object({});
-                break;
-            default:
-                propertyType = zod_1.z.any();
+    return buildFieldsSchema(fields, false, codeSchema);
+}
+/**
+ * Convert field metadata to a Zod schema with every shape the IR carries: nested object
+ * `fields` and `enumValues`, as well as types. Objects keep keys their `fields` don't list. For
+ * describing a tool's arguments to an assistant's model; the Runtime validates with
+ * {@link fieldsToSchema}.
+ *
+ * @param fields Serializable field definitions.
+ */
+function fieldsToShapeSchema(fields) {
+    return buildFieldsSchema(fields, true);
+}
+function enumSchema(values) {
+    if (values.every((value) => typeof value === "string")) {
+        return zod_1.z.enum(values);
+    }
+    const literals = values.map((value) => zod_1.z.literal(value));
+    return literals.length === 1
+        ? literals[0]
+        : zod_1.z.union(literals);
+}
+function fieldValueSchema(field, shapes, open) {
+    if (shapes && field.enumValues?.length) {
+        return enumSchema(field.enumValues);
+    }
+    switch (field.type) {
+        case "id": {
+            const id = zod_1.z.string().refine((value) => (0, utils_1.isid)(value), { message: "Invalid id" });
+            id._def._fieldType = field_type_1.FieldType.id;
+            return id;
         }
+        case "string":
+            return zod_1.z.string();
+        case "number":
+            return zod_1.z.number();
+        case "boolean":
+            return zod_1.z.boolean();
+        case "Date":
+            return zod_1.z.date();
+        case "object": {
+            const object = shapes && field.fields ? buildFieldsSchema(field.fields, true) : zod_1.z.object({});
+            // An author schema intersected with this one parses the value itself; two parses of
+            // one object can't be merged, so only an open object keeps its keys.
+            return open ? object.passthrough() : object;
+        }
+        default:
+            return zod_1.z.any();
+    }
+}
+function buildFieldsSchema(fields, shapes, codeSchema) {
+    let argsSchema = zod_1.z.object({});
+    for (const field of fields) {
+        const { name, description, isArray, defaultValue, optional } = field;
+        const shapeField = codeSchema?.shape?.[name];
+        let propertyType = fieldValueSchema(field, shapes, !shapeField);
         if (isArray) {
             propertyType = propertyType.array();
         }
@@ -49,7 +88,6 @@ function fieldsToSchema(fields, codeSchema) {
             propertyType = propertyType.default(defaultValue);
         }
         propertyType = propertyType.describe(description ?? "");
-        const shapeField = codeSchema?.shape?.[name];
         if (shapeField) {
             propertyType = zod_1.z.intersection(propertyType, shapeField);
         }
@@ -58,6 +96,99 @@ function fieldsToSchema(fields, codeSchema) {
     }
     return argsSchema;
 }
+/**
+ * `value` without its empty fields, as the Runtime stores and delivers it: an optional field
+ * that is `null` or `undefined` is left out, in nested object `fields` too (including each
+ * object in an array). An empty field with a default is removed so parsing fills the default.
+ * A required field without a default keeps its value, so validation still refuses an empty
+ * one. Values inside an object or array that `fields` doesn't describe are left as they are.
+ * Returns `value` itself when nothing is removed, and a copy otherwise; `value` is never changed.
+ *
+ * @param fields The fields describing `value`.
+ * @param value A row, a tool's arguments, or an event payload.
+ */
+function withoutEmptyFields(fields, value) {
+    if (!isPlainRecord(value)) {
+        return value;
+    }
+    let copy;
+    for (const field of fields) {
+        if (!Object.hasOwn(value, field.name)) {
+            continue;
+        }
+        const current = value[field.name];
+        let next = current;
+        if (current === null || current === undefined) {
+            if (!field.optional && field.defaultValue === undefined) {
+                continue;
+            }
+            next = undefined;
+        }
+        else if (field.fields) {
+            next =
+                field.isArray && Array.isArray(current)
+                    ? withoutEmptyItems(field.fields, current)
+                    : withoutEmptyFields(field.fields, current);
+        }
+        if (next === current && next !== undefined) {
+            continue;
+        }
+        copy ??= { ...value };
+        if (next === undefined) {
+            delete copy[field.name];
+        }
+        else {
+            // Define rather than assign, so a "__proto__" field stays a field.
+            Object.defineProperty(copy, field.name, {
+                value: next,
+                enumerable: true,
+                writable: true,
+                configurable: true,
+            });
+        }
+    }
+    return (copy ?? value);
+}
+function withoutEmptyItems(fields, items) {
+    let copy;
+    items.forEach((item, index) => {
+        const next = withoutEmptyFields(fields, item);
+        if (next !== item) {
+            copy ??= [...items];
+            copy[index] = next;
+        }
+    });
+    return copy ?? items;
+}
+function isPlainRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+/**
+ * The fields of a table definition as table-definition comparisons see them: name, description,
+ * type, optional, isArray, and subType, in a fixed order. Left out: `defaultValue` (the database
+ * stores a function default as a string), the keys the IR gained later (`fields` and
+ * `enumValues`), and keys this SDK doesn't know, so rebuilding a package with a newer SDK doesn't
+ * make the same table version look different. A device keeps the definition it stored until the
+ * table's `versionNumber` changes.
+ *
+ * @internal
+ * @param fields A table definition's fields.
+ */
+function comparableTableFields(fields) {
+    return fields.map((field) => {
+        const comparable = {};
+        for (const key of ["name", "description", "type", "optional", "isArray", "subType"]) {
+            if (field[key] !== undefined) {
+                comparable[key] = field[key];
+            }
+        }
+        return comparable;
+    });
+}
 /**
  * Convert a Zod object schema to serializable field metadata.
  *

package/dist/data/orm/types.test.js

@@ -277,4 +277,133 @@ describe("types", () => {
         expect(() => schema.parse({ recordId: validId, label: "hello" })).not.toThrow();
         expect(() => schema.parse({ recordId: "", label: "hello" })).toThrow();
     });
+    describe("the richer IR", () => {
+        const fields = [
+            { name: "mode", type: field_type_1.FieldType.string, enumValues: ["on", "off"] },
+            { name: "note", type: field_type_1.FieldType.string, optional: true },
+            {
+                name: "where",
+                type: field_type_1.FieldType.object,
+                fields: [
+                    { name: "city", type: field_type_1.FieldType.string },
+                    { name: "unit", type: field_type_1.FieldType.string, enumValues: ["F", "C"], optional: true },
+                ],
+            },
+            { name: "tags", type: field_type_1.FieldType.object, isArray: true },
+        ];
+        const valid = {
+            mode: "on",
+            where: { city: "Austin", unit: "F", extra: 1 },
+            tags: [{ a: 1 }],
+        };
+        it("fieldsToSchema checks types and keeps an object's keys", () => {
+            const schema = (0, types_1.fieldsToSchema)(fields);
+            expect(schema.parse(valid)).toEqual(valid);
+            // An empty optional field is removed first (withoutEmptyFields); null itself isn't a value.
+            expect(schema.safeParse({ ...valid, note: null }).success).toBe(false);
+            // Enum values and nested fields describe; the Runtime doesn't enforce them.
+            expect(schema.safeParse({ ...valid, mode: "dim", where: { city: 3 } }).success).toBe(true);
+            expect(schema.safeParse({ ...valid, mode: 1 }).success).toBe(false);
+            expect(schema.safeParse({ ...valid, mode: null }).success).toBe(false);
+            expect(schema.safeParse({ ...valid, where: "Austin" }).success).toBe(false);
+        });
+        it("fieldsToSchema still defers an object to an intersected author schema", () => {
+            const codeSchema = zod_1.z.object({ when: zod_1.z.object({ at: zod_1.z.coerce.date() }) });
+            const schema = (0, types_1.fieldsToSchema)([{ name: "when", type: field_type_1.FieldType.object }], codeSchema);
+            expect(schema.parse({ when: { at: "2026-01-01" } }).when.at).toBeInstanceOf(Date);
+        });
+        it("fieldsToShapeSchema checks enum values and nested fields", () => {
+            const schema = (0, types_1.fieldsToShapeSchema)(fields);
+            expect(schema.parse(valid)).toEqual(valid);
+            expect(schema.safeParse({ ...valid, mode: "dim" }).success).toBe(false);
+            expect(schema.safeParse({ ...valid, where: { city: 3 } }).success).toBe(false);
+            expect(schema.safeParse({ ...valid, where: { city: "Austin", unit: "K" } }).success).toBe(false);
+            const mixed = (0, types_1.fieldsToShapeSchema)([
+                { name: "size", type: field_type_1.FieldType.any, enumValues: [1, "large", true] },
+                { name: "one", type: field_type_1.FieldType.number, enumValues: [3] },
+            ]);
+            expect(mixed.safeParse({ size: true, one: 3 }).success).toBe(true);
+            expect(mixed.safeParse({ size: false, one: 3 }).success).toBe(false);
+            expect(mixed.safeParse({ size: 1, one: 4 }).success).toBe(false);
+        });
+        it("comparableTableFields keeps only the keys a table version is compared on", () => {
+            expect((0, types_1.comparableTableFields)([
+                {
+                    type: field_type_1.FieldType.object,
+                    name: "where",
+                    defaultValue: {},
+                    fields: [],
+                    enumValues: ["x"],
+                    optional: true,
+                    future: 1,
+                },
+            ])).toEqual([{ name: "where", type: field_type_1.FieldType.object, optional: true }]);
+        });
+    });
+    describe("withoutEmptyFields", () => {
+        const fields = [
+            { name: "title", type: field_type_1.FieldType.string },
+            { name: "note", type: field_type_1.FieldType.string, optional: true },
+            {
+                name: "where",
+                type: field_type_1.FieldType.object,
+                optional: true,
+                fields: [
+                    { name: "city", type: field_type_1.FieldType.string },
+                    { name: "unit", type: field_type_1.FieldType.string, optional: true },
+                ],
+            },
+            {
+                name: "stops",
+                type: field_type_1.FieldType.object,
+                isArray: true,
+                fields: [{ name: "at", type: field_type_1.FieldType.string, optional: true }],
+            },
+            { name: "data", type: field_type_1.FieldType.any, optional: true },
+        ];
+        it("removes null and undefined optional fields, in declared nested fields too", () => {
+            const value = {
+                title: "a",
+                note: null,
+                where: { city: "Austin", unit: null },
+                stops: [{ at: null }, { at: "noon" }],
+                data: { inner: null },
+                extra: null,
+            };
+            expect((0, types_1.withoutEmptyFields)(fields, value)).toEqual({
+                title: "a",
+                where: { city: "Austin" },
+                stops: [{}, { at: "noon" }],
+                // Values the fields don't describe, and keys they don't list, are left as they are.
+                data: { inner: null },
+                extra: null,
+            });
+            expect(value.note).toBeNull();
+            expect(value.where.unit).toBeNull();
+            expect((0, types_1.withoutEmptyFields)(fields, { ...value, note: undefined, where: null })).not.toHaveProperty("where");
+        });
+        it("keeps an empty required field, and returns the value itself when nothing is removed", () => {
+            const required = { title: null, stops: [] };
+            expect((0, types_1.withoutEmptyFields)(fields, required)).toBe(required);
+            const clean = { title: "a", where: { city: "Austin" }, stops: [{ at: "noon" }] };
+            expect((0, types_1.withoutEmptyFields)(fields, clean)).toBe(clean);
+            expect((0, types_1.withoutEmptyFields)(fields, null)).toBeNull();
+            expect((0, types_1.withoutEmptyFields)(fields, ["a"])).toEqual(["a"]);
+        });
+        it("deletes own undefined keys at every described depth", () => {
+            const value = { note: undefined, where: { unit: undefined }, stops: [{ at: undefined }] };
+            const cleaned = (0, types_1.withoutEmptyFields)(fields, value);
+            expect(cleaned).toStrictEqual({ where: {}, stops: [{}] });
+            expect(value).toHaveProperty("note");
+            expect(value.where).toHaveProperty("unit");
+        });
+        it("lets parsing fill a default for null just as for a missing field", () => {
+            const defaulted = [{ name: "rank", type: field_type_1.FieldType.number, defaultValue: 5 }];
+            for (const value of [{ rank: null }, { rank: undefined }, {}]) {
+                const cleaned = (0, types_1.withoutEmptyFields)(defaulted, value);
+                expect(cleaned).toStrictEqual({});
+                expect((0, types_1.fieldsToSchema)(defaulted).parse(cleaned)).toStrictEqual({ rank: 5 });
+            }
+        });
+    });
 });