@fluidframework/tree 2.10.0-306579 → 2.10.0-307399

package/lib/feature-libraries/modular-schema/discrepancies.d.ts

@@ -6,39 +6,39 @@ import { type FieldKindIdentifier, type TreeStoredSchema, type ValueSchema } fro
 /**
  * @remarks
  *
- * 1. FieldIncompatibility
+ * 1. FieldDiscrepancy
  *
- * `FieldIncompatibility` represents the differences between two `TreeFieldStoredSchema` objects. It consists of
+ * `FieldDiscrepancy` represents the differences between two `TreeFieldStoredSchema` objects. It consists of
  * three types of incompatibilities:
  *
- * - FieldKindIncompatibility: Indicates the differences in `FieldKindIdentifier` between two `TreeFieldStoredSchema`
+ * - FieldKindDiscrepancy: Indicates the differences in `FieldKindIdentifier` between two `TreeFieldStoredSchema`
  * objects (e.g., optional, required, sequence, etc.).
- * - AllowedTypesIncompatibility: Indicates the differences in the allowed child types between the two schemas.
- * - ValueSchemaIncompatibility: Specifically indicates the differences in the `ValueSchema` of two
+ * - AllowedTypesDiscrepancy: Indicates the differences in the allowed child types between the two schemas.
+ * - ValueSchemaDiscrepancy: Specifically indicates the differences in the `ValueSchema` of two
  * `LeafNodeStoredSchema` objects.
  *
- * 2. NodeIncompatibility
+ * 2. NodeDiscrepancy
  *
- * `NodeIncompatibility` represents the differences between two `TreeNodeStoredSchema` objects and includes:
+ * `NodeDiscrepancy` represents the differences between two `TreeNodeStoredSchema` objects and includes:
  *
- * - NodeKindIncompatibility: Indicates the differences in the types of `TreeNodeStoredSchema` (currently supports
+ * - NodeKindDiscrepancy: Indicates the differences in the types of `TreeNodeStoredSchema` (currently supports
  * `ObjectNodeStoredSchema`, `MapNodeStoredSchema`, and `LeafNodeStoredSchema`).
- * - NodeFieldsIncompatibility: Indicates the `FieldIncompatibility` of `TreeFieldStoredSchema` within two
- * `TreeNodeStoredSchema`. It includes an array of `FieldIncompatibility` instances in the `differences` field.
+ * - NodeFieldsDiscrepancy: Indicates the `FieldDiscrepancy` of `TreeFieldStoredSchema` within two
+ * `TreeNodeStoredSchema`. It includes an array of `FieldDiscrepancy` instances in the `differences` field.
  *
  * When comparing two nodes for compatibility, it only makes sense to compare their fields if the nodes are of
  * the same kind (map, object, leaf).
  *
- * 3. Incompatibility
+ * 3. Discrepancy
  *
- * Incompatibility consists of both `NodeIncompatibility` and `FieldIncompatibility`, representing any kind of
- * schema differences. See {@link getAllowedContentIncompatibilities} for more details about how we process it
+ * Discrepancy consists of both `NodeDiscrepancy` and `FieldDiscrepancy`, representing any kind of
+ * schema differences. See {@link getAllowedContentDiscrepancies} for more details about how we process it
  * and the ordering.
  */
-export type Incompatibility = FieldIncompatibility | NodeIncompatibility;
-export type NodeIncompatibility = NodeKindIncompatibility | NodeFieldsIncompatibility;
-export type FieldIncompatibility = AllowedTypeIncompatibility | FieldKindIncompatibility | ValueSchemaIncompatibility;
-export interface AllowedTypeIncompatibility {
+export type Discrepancy = FieldDiscrepancy | NodeDiscrepancy;
+export type NodeDiscrepancy = NodeKindDiscrepancy | NodeFieldsDiscrepancy;
+export type FieldDiscrepancy = AllowedTypeDiscrepancy | FieldKindDiscrepancy | ValueSchemaDiscrepancy;
+export interface AllowedTypeDiscrepancy {
     identifier: string | undefined;
     mismatch: "allowedTypes";
     /**
@@ -50,48 +50,48 @@ export interface AllowedTypeIncompatibility {
      */
     stored: string[];
 }
-export interface FieldKindIncompatibility {
+export interface FieldKindDiscrepancy {
     identifier: string | undefined;
     mismatch: "fieldKind";
     view: FieldKindIdentifier;
     stored: FieldKindIdentifier;
 }
-export interface ValueSchemaIncompatibility {
+export interface ValueSchemaDiscrepancy {
     identifier: string;
     mismatch: "valueSchema";
     view: ValueSchema | undefined;
     stored: ValueSchema | undefined;
 }
-export interface NodeKindIncompatibility {
+export interface NodeKindDiscrepancy {
     identifier: string;
     mismatch: "nodeKind";
     view: SchemaFactoryNodeKind | undefined;
     stored: SchemaFactoryNodeKind | undefined;
 }
-export interface NodeFieldsIncompatibility {
+export interface NodeFieldsDiscrepancy {
     identifier: string;
     mismatch: "fields";
-    differences: FieldIncompatibility[];
+    differences: FieldDiscrepancy[];
 }
 type SchemaFactoryNodeKind = "object" | "leaf" | "map";
 /**
- * @remarks
+ * Finds and reports discrepancies between a view schema and a stored schema.
  *
  * The workflow for finding schema incompatibilities:
- * 1. Compare the two root schemas to identify any `FieldIncompatibility`.
+ * 1. Compare the two root schemas to identify any `FieldDiscrepancy`.
  *
  * 2. For each node schema in the `view`:
  * - Verify if the node schema exists in the stored. If it does, ensure that the `SchemaFactoryNodeKind` are
- * consistent. Otherwise this difference is treated as `NodeKindIncompatibility`
+ * consistent. Otherwise this difference is treated as `NodeKindDiscrepancy`
  * - If a node schema with the same identifier exists in both view and stored, and their `SchemaFactoryNodeKind`
- * are consistent, perform a exhaustive validation to identify all `FieldIncompatibility`.
+ * are consistent, perform a exhaustive validation to identify all `FieldDiscrepancy`.
  *
  * 3. For each node schema in the stored, verify if it exists in the view. The overlapping parts were already
  * addressed in the previous step.
  *
  * @returns the discrepancies between two TreeStoredSchema objects
  */
-export declare function getAllowedContentIncompatibilities(view: TreeStoredSchema, stored: TreeStoredSchema): Incompatibility[];
+export declare function getAllowedContentDiscrepancies(view: TreeStoredSchema, stored: TreeStoredSchema): Iterable<Discrepancy>;
 /**
  * @remarks
  *

package/lib/feature-libraries/modular-schema/discrepancies.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"discrepancies.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/modular-schema/discrepancies.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAEN,KAAK,mBAAmB,EAOxB,KAAK,gBAAgB,EAErB,KAAK,WAAW,EAChB,MAAM,qBAAqB,CAAC;AAO7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,MAAM,eAAe,GAAG,oBAAoB,GAAG,mBAAmB,CAAC;AAEzE,MAAM,MAAM,mBAAmB,GAAG,uBAAuB,GAAG,yBAAyB,CAAC;AAEtF,MAAM,MAAM,oBAAoB,GAC7B,0BAA0B,GAC1B,wBAAwB,GACxB,0BAA0B,CAAC;AAE9B,MAAM,WAAW,0BAA0B;IAC1C,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,QAAQ,EAAE,cAAc,CAAC;IACzB;;OAEG;IACH,IAAI,EAAE,MAAM,EAAE,CAAC;IACf;;OAEG;IACH,MAAM,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,wBAAwB;IACxC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,QAAQ,EAAE,WAAW,CAAC;IACtB,IAAI,EAAE,mBAAmB,CAAC;IAC1B,MAAM,EAAE,mBAAmB,CAAC;CAC5B;AAED,MAAM,WAAW,0BAA0B;IAC1C,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,aAAa,CAAC;IACxB,IAAI,EAAE,WAAW,GAAG,SAAS,CAAC;IAC9B,MAAM,EAAE,WAAW,GAAG,SAAS,CAAC;CAChC;AAED,MAAM,WAAW,uBAAuB;IACvC,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,UAAU,CAAC;IACrB,IAAI,EAAE,qBAAqB,GAAG,SAAS,CAAC;IACxC,MAAM,EAAE,qBAAqB,GAAG,SAAS,CAAC;CAC1C;AAED,MAAM,WAAW,yBAAyB;IACzC,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,QAAQ,CAAC;IACnB,WAAW,EAAE,oBAAoB,EAAE,CAAC;CACpC;AAED,KAAK,qBAAqB,GAAG,QAAQ,GAAG,MAAM,GAAG,KAAK,CAAC;AAEvD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kCAAkC,CACjD,IAAI,EAAE,gBAAgB,EACtB,MAAM,EAAE,gBAAgB,GACtB,eAAe,EAAE,CA8JnB;AAwGD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,gBAAgB,EAAE,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAkCxF"}
+{"version":3,"file":"discrepancies.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/modular-schema/discrepancies.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EACN,KAAK,mBAAmB,EAQxB,KAAK,gBAAgB,EAErB,KAAK,WAAW,EAChB,MAAM,qBAAqB,CAAC;AAO7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,MAAM,WAAW,GAAG,gBAAgB,GAAG,eAAe,CAAC;AAE7D,MAAM,MAAM,eAAe,GAAG,mBAAmB,GAAG,qBAAqB,CAAC;AAE1E,MAAM,MAAM,gBAAgB,GACzB,sBAAsB,GACtB,oBAAoB,GACpB,sBAAsB,CAAC;AAE1B,MAAM,WAAW,sBAAsB;IACtC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,QAAQ,EAAE,cAAc,CAAC;IACzB;;OAEG;IACH,IAAI,EAAE,MAAM,EAAE,CAAC;IACf;;OAEG;IACH,MAAM,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,oBAAoB;IACpC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,QAAQ,EAAE,WAAW,CAAC;IACtB,IAAI,EAAE,mBAAmB,CAAC;IAC1B,MAAM,EAAE,mBAAmB,CAAC;CAC5B;AAED,MAAM,WAAW,sBAAsB;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,aAAa,CAAC;IACxB,IAAI,EAAE,WAAW,GAAG,SAAS,CAAC;IAC9B,MAAM,EAAE,WAAW,GAAG,SAAS,CAAC;CAChC;AAED,MAAM,WAAW,mBAAmB;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,UAAU,CAAC;IACrB,IAAI,EAAE,qBAAqB,GAAG,SAAS,CAAC;IACxC,MAAM,EAAE,qBAAqB,GAAG,SAAS,CAAC;CAC1C;AAED,MAAM,WAAW,qBAAqB;IACrC,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,QAAQ,CAAC;IACnB,WAAW,EAAE,gBAAgB,EAAE,CAAC;CAChC;AAED,KAAK,qBAAqB,GAAG,QAAQ,GAAG,MAAM,GAAG,KAAK,CAAC;AAavD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAiB,8BAA8B,CAC9C,IAAI,EAAE,gBAAgB,EACtB,MAAM,EAAE,gBAAgB,GACtB,QAAQ,CAAC,WAAW,CAAC,CAkCvB;AAkLD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,gBAAgB,EAAE,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAkCxF"}

package/lib/feature-libraries/modular-schema/discrepancies.js

@@ -5,209 +5,144 @@
 import { assert } from "@fluidframework/core-utils/internal";
 import { LeafNodeStoredSchema, MapNodeStoredSchema, ObjectNodeStoredSchema, storedEmptyFieldSchema, } from "../../core/index.js";
 import { brand } from "../../util/index.js";
+function getNodeSchemaType(nodeSchema) {
+    if (nodeSchema instanceof ObjectNodeStoredSchema) {
+        return "object";
+    }
+    else if (nodeSchema instanceof MapNodeStoredSchema) {
+        return "map";
+    }
+    else if (nodeSchema instanceof LeafNodeStoredSchema) {
+        return "leaf";
+    }
+    throwUnsupportedNodeType(nodeSchema.constructor.name);
+}
 /**
- * @remarks
+ * Finds and reports discrepancies between a view schema and a stored schema.
  *
  * The workflow for finding schema incompatibilities:
- * 1. Compare the two root schemas to identify any `FieldIncompatibility`.
+ * 1. Compare the two root schemas to identify any `FieldDiscrepancy`.
  *
  * 2. For each node schema in the `view`:
  * - Verify if the node schema exists in the stored. If it does, ensure that the `SchemaFactoryNodeKind` are
- * consistent. Otherwise this difference is treated as `NodeKindIncompatibility`
+ * consistent. Otherwise this difference is treated as `NodeKindDiscrepancy`
  * - If a node schema with the same identifier exists in both view and stored, and their `SchemaFactoryNodeKind`
- * are consistent, perform a exhaustive validation to identify all `FieldIncompatibility`.
+ * are consistent, perform a exhaustive validation to identify all `FieldDiscrepancy`.
  *
  * 3. For each node schema in the stored, verify if it exists in the view. The overlapping parts were already
  * addressed in the previous step.
  *
  * @returns the discrepancies between two TreeStoredSchema objects
  */
-export function getAllowedContentIncompatibilities(view, stored) {
-    const incompatibilities = [];
+export function* getAllowedContentDiscrepancies(view, stored) {
     // check root schema discrepancies
-    incompatibilities.push(...trackFieldDiscrepancies(view.rootFieldSchema, stored.rootFieldSchema));
-    // Verify the existence and type of a node schema given its identifier (key), then determine if
-    // an exhaustive search is necessary.
-    const viewNodeKeys = new Set();
-    for (const [key, viewNodeSchema] of view.nodeSchema) {
-        viewNodeKeys.add(key);
-        if (viewNodeSchema instanceof ObjectNodeStoredSchema) {
-            if (!stored.nodeSchema.has(key)) {
-                incompatibilities.push({
-                    identifier: key,
+    yield* getFieldDiscrepancies(view.rootFieldSchema, stored.rootFieldSchema);
+    for (const result of compareMaps(view.nodeSchema, stored.nodeSchema)) {
+        switch (result.type) {
+            case "aExtra": {
+                const viewType = getNodeSchemaType(result.value);
+                yield {
+                    identifier: result.key,
                     mismatch: "nodeKind",
-                    view: "object",
+                    view: viewType,
                     stored: undefined,
-                });
-            }
-            else {
-                const storedNodeSchema = stored.nodeSchema.get(key);
-                assert(storedNodeSchema !== undefined, 0x9be /* The storedNodeSchema in stored.nodeSchema should not be undefined */);
-                if (storedNodeSchema instanceof MapNodeStoredSchema) {
-                    incompatibilities.push({
-                        identifier: key,
-                        mismatch: "nodeKind",
-                        view: "object",
-                        stored: "map",
-                    });
-                }
-                else if (storedNodeSchema instanceof LeafNodeStoredSchema) {
-                    incompatibilities.push({
-                        identifier: key,
-                        mismatch: "nodeKind",
-                        view: "object",
-                        stored: "leaf",
-                    });
-                }
-                else if (storedNodeSchema instanceof ObjectNodeStoredSchema) {
-                    const differences = trackObjectNodeDiscrepancies(viewNodeSchema, storedNodeSchema);
-                    if (differences.length > 0) {
-                        incompatibilities.push({
-                            identifier: key,
-                            mismatch: "fields",
-                            differences,
-                        });
-                    }
-                }
-                else {
-                    throwUnsupportedNodeType(storedNodeSchema.constructor.name);
-                }
+                };
+                break;
             }
-        }
-        else if (viewNodeSchema instanceof MapNodeStoredSchema) {
-            if (!stored.nodeSchema.has(key)) {
-                incompatibilities.push({
-                    identifier: key,
+            case "bExtra": {
+                const storedType = getNodeSchemaType(result.value);
+                yield {
+                    identifier: result.key,
                     mismatch: "nodeKind",
-                    view: "map",
-                    stored: undefined,
-                });
+                    view: undefined,
+                    stored: storedType,
+                };
+                break;
             }
-            else {
-                const storedNodeSchema = stored.nodeSchema.get(key);
-                assert(storedNodeSchema !== undefined, 0x9bf /* The storedNodeSchema in stored.nodeSchema should not be undefined */);
-                if (storedNodeSchema instanceof ObjectNodeStoredSchema) {
-                    incompatibilities.push({
-                        identifier: key,
-                        mismatch: "nodeKind",
-                        view: "map",
-                        stored: "object",
-                    });
-                }
-                else if (storedNodeSchema instanceof LeafNodeStoredSchema) {
-                    incompatibilities.push({
-                        identifier: key,
-                        mismatch: "nodeKind",
-                        view: "map",
-                        stored: "leaf",
-                    });
-                }
-                else if (storedNodeSchema instanceof MapNodeStoredSchema) {
-                    incompatibilities.push(...trackFieldDiscrepancies(viewNodeSchema.mapFields, storedNodeSchema.mapFields, key));
-                }
-                else {
-                    throwUnsupportedNodeType(storedNodeSchema.constructor.name);
-                }
+            case "both": {
+                yield* getNodeDiscrepancies(result.key, result.valueA, result.valueB);
+                break;
             }
+            default:
+                break;
         }
-        else if (viewNodeSchema instanceof LeafNodeStoredSchema) {
-            if (!stored.nodeSchema.has(key)) {
-                incompatibilities.push({
-                    identifier: key,
-                    mismatch: "nodeKind",
-                    view: "leaf",
-                    stored: undefined,
-                });
-            }
-            else {
-                const storedNodeSchema = stored.nodeSchema.get(key);
-                assert(storedNodeSchema !== undefined, 0x9c0 /* The storedNodeSchema in stored.nodeSchema should not be undefined */);
-                if (storedNodeSchema instanceof MapNodeStoredSchema) {
-                    incompatibilities.push({
-                        identifier: key,
-                        mismatch: "nodeKind",
-                        view: "leaf",
-                        stored: "map",
-                    });
-                }
-                else if (storedNodeSchema instanceof ObjectNodeStoredSchema) {
-                    incompatibilities.push({
-                        identifier: key,
-                        mismatch: "nodeKind",
-                        view: "leaf",
-                        stored: "object",
-                    });
-                }
-                else if (storedNodeSchema instanceof LeafNodeStoredSchema) {
-                    if (viewNodeSchema.leafValue !== storedNodeSchema.leafValue) {
-                        incompatibilities.push({
-                            identifier: key,
-                            mismatch: "valueSchema",
-                            view: viewNodeSchema.leafValue,
-                            stored: storedNodeSchema.leafValue,
-                        });
-                    }
-                }
-                else {
-                    throwUnsupportedNodeType(storedNodeSchema.constructor.name);
-                }
+    }
+}
+function* getNodeDiscrepancies(identifier, view, stored) {
+    const viewType = getNodeSchemaType(view);
+    const storedType = getNodeSchemaType(stored);
+    if (viewType !== storedType) {
+        yield {
+            identifier,
+            mismatch: "nodeKind",
+            view: viewType,
+            stored: storedType,
+        };
+        return;
+    }
+    switch (viewType) {
+        case "object": {
+            const differences = Array.from(trackObjectNodeDiscrepancies(view, stored));
+            if (differences.length > 0) {
+                yield {
+                    identifier,
+                    mismatch: "fields",
+                    differences,
+                };
             }
+            break;
         }
-        else {
-            throwUnsupportedNodeType(viewNodeSchema.constructor.name);
-        }
-    }
-    for (const [key, storedNodeSchema] of stored.nodeSchema) {
-        if (!viewNodeKeys.has(key)) {
-            incompatibilities.push({
-                identifier: key,
-                mismatch: "nodeKind",
-                view: undefined,
-                stored: storedNodeSchema instanceof MapNodeStoredSchema
-                    ? "map"
-                    : storedNodeSchema instanceof ObjectNodeStoredSchema
-                        ? "object"
-                        : "leaf",
-            });
+        case "map":
+            yield* getFieldDiscrepancies(view.mapFields, stored.mapFields, identifier);
+            break;
+        case "leaf": {
+            const viewValue = view.leafValue;
+            const storedValue = stored.leafValue;
+            if (viewValue !== storedValue) {
+                yield {
+                    identifier,
+                    mismatch: "valueSchema",
+                    view: viewValue,
+                    stored: storedValue,
+                };
+            }
+            break;
         }
+        default:
+            break;
     }
-    return incompatibilities;
 }
 /**
  * The function to track the discrepancies between two field stored schemas.
  *
  * @param keyOrRoot - If the key is missing, it indicates that this is the root field schema.
  */
-function trackFieldDiscrepancies(view, stored, keyOrRoot) {
-    const differences = [];
+function* getFieldDiscrepancies(view, stored, keyOrRoot) {
     // Only track the symmetric differences of two sets.
     const findSetDiscrepancies = (a, b) => {
         const aDiff = [...a].filter((value) => !b.has(value));
         const bDiff = [...b].filter((value) => !a.has(value));
         return [aDiff, bDiff];
     };
-    const allowedTypesDiscrepancies = findSetDiscrepancies(view.types, stored.types);
-    if (allowedTypesDiscrepancies[0].length > 0 || allowedTypesDiscrepancies[1].length > 0) {
-        differences.push({
+    const [viewExtra, storedExtra] = findSetDiscrepancies(view.types, stored.types);
+    if (viewExtra.length > 0 || storedExtra.length > 0) {
+        yield {
             identifier: keyOrRoot,
             mismatch: "allowedTypes",
-            view: allowedTypesDiscrepancies[0],
-            stored: allowedTypesDiscrepancies[1],
-        });
+            view: viewExtra,
+            stored: storedExtra,
+        };
     }
     if (view.kind !== stored.kind) {
-        differences.push({
+        yield {
             identifier: keyOrRoot,
             mismatch: "fieldKind",
             view: view.kind,
             stored: stored.kind,
-        });
+        };
     }
-    return differences;
 }
-function trackObjectNodeDiscrepancies(view, stored) {
-    const differences = [];
-    const viewFieldKeys = new Set();
+function* trackObjectNodeDiscrepancies(view, stored) {
     /**
      * Similar to the logic used for tracking discrepancies between two node schemas, we will identify
      * three types of differences:
@@ -218,35 +153,59 @@ function trackObjectNodeDiscrepancies(view, stored) {
      * First, the view schema is iterated to track the first two types of differences.
      * Then, the stored schema is iterated to find the third type.
      */
-    for (const [fieldKey, fieldStoredSchema] of view.objectNodeFields) {
-        viewFieldKeys.add(fieldKey);
-        if (!stored.objectNodeFields.has(fieldKey) &&
-            fieldStoredSchema.kind !== storedEmptyFieldSchema.kind) {
-            differences.push({
-                identifier: fieldKey,
-                mismatch: "fieldKind",
-                view: fieldStoredSchema.kind,
-                stored: storedEmptyFieldSchema.kind,
-            });
-        }
-        else {
-            differences.push(...trackFieldDiscrepancies(view.objectNodeFields.get(fieldKey), stored.objectNodeFields.get(fieldKey), fieldKey));
+    for (const result of compareMaps(view.objectNodeFields, stored.objectNodeFields)) {
+        const fieldKey = result.key;
+        switch (result.type) {
+            case "aExtra": {
+                if (result.value.kind === storedEmptyFieldSchema.kind) {
+                    // In one of view/stored, this field is explicitly forbidden, but in the other it is implicitly forbidden
+                    // (by way of omission). We treat these identically anyway.
+                    break;
+                }
+                yield {
+                    identifier: fieldKey,
+                    mismatch: "fieldKind",
+                    view: result.value.kind,
+                    stored: storedEmptyFieldSchema.kind,
+                };
+                break;
+            }
+            case "bExtra": {
+                if (result.value.kind === storedEmptyFieldSchema.kind) {
+                    // In one of view/stored, this field is explicitly forbidden, but in the other it is implicitly forbidden
+                    // (by way of omission). We treat these identically anyway.
+                    break;
+                }
+                yield {
+                    identifier: fieldKey,
+                    mismatch: "fieldKind",
+                    view: storedEmptyFieldSchema.kind,
+                    stored: result.value.kind,
+                };
+                break;
+            }
+            case "both": {
+                yield* getFieldDiscrepancies(result.valueA, result.valueB, fieldKey);
+                break;
+            }
+            default: {
+                break;
+            }
         }
     }
-    for (const [fieldKey, fieldStoredSchema] of stored.objectNodeFields) {
-        if (viewFieldKeys.has(fieldKey)) {
-            continue;
-        }
-        if (fieldStoredSchema.kind !== storedEmptyFieldSchema.kind) {
-            differences.push({
-                identifier: fieldKey,
-                mismatch: "fieldKind",
-                view: storedEmptyFieldSchema.kind,
-                stored: fieldStoredSchema.kind,
-            });
+}
+function* compareMaps(a, b) {
+    for (const [key, valueA] of a) {
+        const valueB = b.get(key);
+        yield valueB === undefined
+            ? { type: "aExtra", key, value: valueA }
+            : { type: "both", key, valueA, valueB };
+    }
+    for (const [key, valueB] of b) {
+        if (!a.has(key)) {
+            yield { type: "bExtra", key, value: valueB };
         }
     }
-    return differences;
 }
 /**
  * @remarks
@@ -266,11 +225,11 @@ function trackObjectNodeDiscrepancies(view, stored) {
  * validating internal fields.
  */
 export function isRepoSuperset(view, stored) {
-    const incompatibilities = getAllowedContentIncompatibilities(view, stored);
-    for (const incompatibility of incompatibilities) {
-        switch (incompatibility.mismatch) {
+    const discrepancies = getAllowedContentDiscrepancies(view, stored);
+    for (const discrepancy of discrepancies) {
+        switch (discrepancy.mismatch) {
             case "nodeKind": {
-                if (incompatibility.stored !== undefined) {
+                if (discrepancy.stored !== undefined) {
                     // It's fine for the view schema to know of a node type that the stored schema doesn't know about.
                     return false;
                 }
@@ -279,13 +238,13 @@ export function isRepoSuperset(view, stored) {
             case "valueSchema":
             case "allowedTypes":
             case "fieldKind": {
-                if (!validateFieldIncompatibility(incompatibility)) {
+                if (!isFieldDiscrepancyCompatible(discrepancy)) {
                     return false;
                 }
                 break;
             }
             case "fields": {
-                if (incompatibility.differences.some((difference) => !validateFieldIncompatibility(difference))) {
+                if (discrepancy.differences.some((difference) => !isFieldDiscrepancyCompatible(difference))) {
                     return false;
                 }
                 break;
@@ -295,16 +254,16 @@ export function isRepoSuperset(view, stored) {
     }
     return true;
 }
-function validateFieldIncompatibility(incompatibility) {
-    switch (incompatibility.mismatch) {
+function isFieldDiscrepancyCompatible(discrepancy) {
+    switch (discrepancy.mismatch) {
         case "allowedTypes": {
             // Since we only track the symmetric difference between the allowed types in the view and
             // stored schemas, it's sufficient to check if any extra allowed types still exist in the
             // stored schema.
-            return incompatibility.stored.length === 0;
+            return discrepancy.stored.length === 0;
         }
         case "fieldKind": {
-            return posetLte(incompatibility.stored, incompatibility.view, fieldRealizer);
+            return posetLte(discrepancy.stored, discrepancy.view, fieldRealizer);
         }
         case "valueSchema": {
             return false;