@peers-app/peers-sdk 0.26.5 → 0.27.0

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

@@ -258,6 +258,7 @@ class SQLDataSource {
             // @ts-expect-error - need to figure out how to get typescript to understand what's going on here
             record[this.metaData.primaryKeyName] = (0, utils_1.newid)();
         }
+        this.removeEmptyFields(record);
         this.applySchemaDefaults(record);
         const fields = this.metaData.fields.map((field) => `"${field.name}"`).join(", ");
         const values = this.metaData.fields.map((field) => jsValueToSqlValue(record[field.name]));
@@ -276,8 +277,9 @@ class SQLDataSource {
         // Explicit catalog patches write only their own columns. Keep ordinary row-save
         // semantics (omitted optional fields clear) unchanged for all other writes.
         const catalogPatch = this.tableName === "Tools" && (0, tool_catalog_fields_1.isToolCatalogPatch)(record);
+        const defaulted = catalogPatch ? [] : this.removeEmptyFields(record);
         const updated = catalogPatch ? { ...(await this.get(primaryKey)), ...record } : record;
-        this.schema.parse(updated);
+        this.applyDefaults(record, this.schema.parse(updated), defaulted);
         const updateFields = this.fieldsForUpdate(record).filter((field) => !catalogPatch || Object.hasOwn(record, field.name));
         if (updateFields.length === 0) {
             return updated;
@@ -327,6 +329,47 @@ class SQLDataSource {
             }
         }
     }
+    /**
+     * Remove `record`'s empty fields in place, so a row is written and returned as it's stored:
+     * an optional field that is `null` or `undefined` is left out, and so is an empty field with a
+     * default, which gets the default. Returns the defaulted fields' names. A required field
+     * without a default keeps its value for validation to refuse.
+     */
+    removeEmptyFields(record) {
+        const writable = record;
+        const cleaned = (0, types_1.withoutEmptyFields)(this.metaData.fields, writable);
+        const defaulted = [];
+        for (const field of this.metaData.fields) {
+            // A missing optional column is cleared on update too. Its default must win over NULL;
+            // a missing required column still keeps the stored value for older syncing peers.
+            if (field.defaultValue !== undefined &&
+                writable[field.name] == null &&
+                (Object.hasOwn(writable, field.name) || field.optional)) {
+                defaulted.push(field.name);
+            }
+            if (!Object.hasOwn(writable, field.name)) {
+                continue;
+            }
+            if (!Object.hasOwn(cleaned, field.name)) {
+                delete writable[field.name];
+            }
+            else if (cleaned[field.name] !== writable[field.name]) {
+                writable[field.name] = cleaned[field.name];
+            }
+        }
+        return defaulted;
+    }
+    /** Copy the parsed defaults requested by {@link removeEmptyFields} onto `record`. */
+    applyDefaults(record, parsed, names) {
+        for (const name of names) {
+            if (parsed[name] === undefined) {
+                delete record[name];
+            }
+            else {
+                record[name] = parsed[name];
+            }
+        }
+    }
     /**
      * Columns to SET on update. Required fields that are missing are omitted so
      * older peers without a new column do not overwrite a local value with NULL.
@@ -366,6 +409,7 @@ class SQLDataSource {
             // @ts-expect-error - need to figure out how to get typescript to understand what's going on here
             record[this.metaData.primaryKeyName] = (0, utils_1.newid)();
         }
+        this.removeEmptyFields(record);
         this.applySchemaDefaults(record);
         const fields = this.metaData.fields.map((field) => `"${field.name}"`).join(", ");
         const values = this.metaData.fields.map((field) => jsValueToSqlValue(record[field.name]));
@@ -383,7 +427,8 @@ class SQLDataSource {
             // @ts-expect-error - need to figure out how to get typescript to understand what's going on here
             record[this.metaData.primaryKeyName] = (0, utils_1.newid)();
         }
-        this.schema.parse(record);
+        const defaulted = this.removeEmptyFields(record);
+        this.applyDefaults(record, this.schema.parse(record), defaulted);
         const primaryKey = record[this.metaData.primaryKeyName];
         const updateFields = this.fieldsForUpdate(record);
         if (updateFields.length === 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.
  *