openai 7.16.0 → 7.17.0

package/lib/transform.js

@@ -108,6 +108,7 @@ function assignSchema(target, ...sources) {
  * participate.
  */
 function forEachJSONSchemaChild(schema, path, visit) {
+    // SAFETY: This is an object schema at this traversal point; the record view permits dynamic keyword access while individual values remain subject to schema checks.
     const record = schema;
     for (const keyword of JSON_SCHEMA_SINGLE_SCHEMA_KEYWORDS) {
         if (keyword in record) {
@@ -180,10 +181,11 @@ function toStrictJsonSchema(schema) {
     return strictSchema;
 }
 function stripUndefinedSchemaKeywords(schema, visited = new Set()) {
-    if (typeof schema === 'boolean' || !isObject(schema) || visited.has(schema)) {
+    if (!isObject(schema) || visited.has(schema)) {
         return;
     }
     visited.add(schema);
+    // SAFETY: This is an object schema at this traversal point; the record view permits dynamic keyword access while individual values remain subject to schema checks.
     const schemaRecord = schema;
     for (const keyword of Object.keys(schemaRecord)) {
         if (schemaRecord[keyword] === undefined) {
@@ -191,6 +193,7 @@ function stripUndefinedSchemaKeywords(schema, visited = new Set()) {
         }
     }
     forEachJSONSchemaChild(schema, [], (child) => {
+        // SAFETY: The schema-child visitor supplies only recognized object or boolean schema positions; the recursive helper validates their contents.
         stripUndefinedSchemaKeywords(child, visited);
     });
 }
@@ -266,6 +269,7 @@ function inlineRootRefObject(schema) {
         }
         for (const keyword of JSON_SCHEMA_ANNOTATION_KEYWORDS) {
             if (!(keyword in inheritedAnnotations) && keyword in target) {
+                // SAFETY: This is an object schema at this traversal point; the record view permits dynamic keyword access while individual values remain subject to schema checks.
                 inheritedAnnotations[keyword] = target[keyword];
             }
         }
@@ -284,6 +288,7 @@ function inlineRootRefObject(schema) {
             delete inlined[keyword];
         }
     }
+    // SAFETY: This is an object schema at this traversal point; the record view permits dynamic keyword access while individual values remain subject to schema checks.
     const schemaRecord = schema;
     for (const keyword of Object.keys(schema)) {
         delete schemaRecord[keyword];
@@ -322,12 +327,13 @@ function normalizeRootAllOf(schema) {
             return;
         }
         const branch = allOf[0];
-        if (typeof branch === 'boolean' || !isObject(branch)) {
+        if (!isObject(branch)) {
             return;
         }
         const rootMetadata = { ...schema };
         delete rootMetadata.allOf;
         const normalized = structuredClone(branch);
+        // SAFETY: This is an object schema at this traversal point; the record view permits dynamic keyword access while individual values remain subject to schema checks.
         const schemaRecord = schema;
         for (const keyword of Object.keys(schema)) {
             delete schemaRecord[keyword];
@@ -356,7 +362,7 @@ function normalizeRootAnyOf(schema) {
         return false;
     }
     const { branch, index: branchIndex } = realBranches[0];
-    if (typeof branch === 'boolean' || !isObject(branch) || !isObjectOnlySchema(branch, schema)) {
+    if (!isObject(branch) || !isObjectOnlySchema(branch, schema)) {
         return false;
     }
     const definitionRenames = planPromotedRootAnyOfDefinitionRenames(schema, branch);
@@ -383,6 +389,7 @@ function normalizeRootAnyOf(schema) {
         normalized[keyword] = mergedDefinitions;
         delete rootMetadata[keyword];
     }
+    // SAFETY: This is an object schema at this traversal point; the record view permits dynamic keyword access while individual values remain subject to schema checks.
     const schemaRecord = schema;
     for (const keyword of Object.keys(schema)) {
         delete schemaRecord[keyword];
@@ -447,13 +454,14 @@ function rewriteLocalRefsIntoPromotedRootAnyOfBranch(root, branchIndex, definiti
             : '#/' + promotedParts.map(encodeJSONPointerTokenForURIFragment).join('/');
     };
     const rewriteRefs = (value) => {
-        if (typeof value === 'boolean' || !isObject(value)) {
+        if (!isObject(value)) {
             return;
         }
         if (typeof value.$ref === 'string') {
             value.$ref = rewriteRef(value.$ref);
         }
         forEachJSONSchemaChild(value, [], (child) => {
+            // SAFETY: The schema-child visitor supplies only recognized object or boolean schema positions; the recursive helper validates their contents.
             rewriteRefs(child);
         });
     };
@@ -481,13 +489,14 @@ function hasOnlyRootRefAndDefinitions(schema) {
  * Multi-type arrays carry real union semantics and must remain unchanged.
  */
 function normalizeSingletonTypeArrays(schema) {
-    if (typeof schema === 'boolean' || !isObject(schema)) {
+    if (!isObject(schema)) {
         return;
     }
     if (Array.isArray(schema.type) && schema.type.length === 1) {
         schema.type = schema.type[0];
     }
     forEachJSONSchemaChild(schema, [], (child) => {
+        // SAFETY: The schema-child visitor supplies only recognized object or boolean schema positions; the recursive helper validates their contents.
         normalizeSingletonTypeArrays(child);
     });
 }
@@ -578,7 +587,7 @@ function ensureStrictJsonSchema(jsonSchema, path, root) {
     // keywords without an explicit type, so those implicit object shapes need
     // the same strict handling as type: 'object'. Explicitly open object schemas
     // cannot be represented in Structured Outputs strict mode.
-    if (hasObjectShape(jsonSchema)) {
+    if (hasObjectConstraints(jsonSchema)) {
         if (!(0, utils_1.hasOwn)(jsonSchema, 'additionalProperties')) {
             jsonSchema.additionalProperties = false;
         }
@@ -592,7 +601,7 @@ function ensureStrictJsonSchema(jsonSchema, path, root) {
     }
     // Handle object properties
     const properties = jsonSchema.properties;
-    if (hasObjectShape(jsonSchema)) {
+    if (hasObjectConstraints(jsonSchema)) {
         for (const key of required) {
             if (!isObject(properties) || !(0, utils_1.hasOwn)(properties, key)) {
                 throw new Error(`Object schema at \`${path.join('/') || '<root>'}\` requires property \`${key}\` but does not declare it in \`properties\`.`);
@@ -639,6 +648,7 @@ function ensureStrictJsonSchema(jsonSchema, path, root) {
         }
     }
     normalizeArrayUnionWrapper(jsonSchema, root);
+    // SAFETY: This is an object schema at this traversal point; the record view permits dynamic keyword access while individual values remain subject to schema checks.
     const schemaRecord = jsonSchema;
     for (const keyword of JSON_SCHEMA_UNSUPPORTED_SCHEMA_KEYWORDS) {
         // Optional converter output often keeps undefined placeholders on the
@@ -662,6 +672,7 @@ function ensureStrictJsonSchema(jsonSchema, path, root) {
         if (typeof child === 'boolean' && (keyword === 'additionalProperties' || keyword === 'additionalItems')) {
             return;
         }
+        // SAFETY: The schema-child visitor supplies only recognized object or boolean schema positions; the recursive helper validates their contents.
         ensureStrictJsonSchema(child, childPath, root);
     });
     // Strip `null` defaults as there's no meaningful distinction
@@ -701,6 +712,7 @@ function parseLocalRef(ref) {
     }
     return parts;
 }
+// oxlint-disable-next-line anti-slop/no-unknown-returns -- Resolving untrusted schema references may produce any value; callers perform the schema checks. JSON Schema traversal accepts arbitrary keyword values and validates each node before interpreting it.
 function resolvePointerPart(resolved, part) {
     if (Array.isArray(resolved)) {
         if (!/^(?:0|[1-9]\d*)$/.test(part)) {
@@ -780,7 +792,7 @@ function isSchemaDefinition(value) {
     return typeof value === 'boolean' || isObject(value);
 }
 function isObjectOnlySchema(schema, root, seenRefs = new Set()) {
-    if (typeof schema === 'boolean' || !isObject(schema)) {
+    if (!isObject(schema)) {
         return false;
     }
     if (schema.$ref !== undefined) {
@@ -808,7 +820,7 @@ function isObjectOnlySchema(schema, root, seenRefs = new Set()) {
         (Array.isArray(schema.type) && schema.type.length === 1 && schema.type[0] === 'object'));
 }
 function isArrayOnlySchema(schema, root, seenRefs = new Set()) {
-    if (typeof schema === 'boolean' || !isObject(schema)) {
+    if (!isObject(schema)) {
         return false;
     }
     if (schema.$ref !== undefined) {
@@ -846,6 +858,7 @@ function hasOnlyRefAndAnnotations(schema) {
         JSON_SCHEMA_ANNOTATION_KEYWORDS.has(keyword));
 }
 function hasOnlyAnnotationSiblings(schema, keyword) {
+    // SAFETY: This is an object schema at this traversal point; the record view permits dynamic keyword access while individual values remain subject to schema checks.
     const schemaRecord = schema;
     return Object.keys(schema).every(
     // Definition maps do not add sibling validation constraints. Keep them
@@ -874,7 +887,7 @@ function hasOnlyRootAnyOfMetadataSiblings(schema) {
 function hasObjectKeywords(schema) {
     return Object.keys(schema).some((keyword) => JSON_SCHEMA_OBJECT_KEYWORDS.has(keyword));
 }
-function hasObjectShape(schema) {
+function hasObjectConstraints(schema) {
     const typ = schema.type;
     return (typ === 'object' ||
         (Array.isArray(typ) && typ.includes('object')) ||
@@ -896,7 +909,7 @@ function normalizeObjectUnionWrapper(jsonSchema, path, root) {
     if (hasEmptyRequired) {
         delete jsonSchema.required;
     }
-    if (!hasObjectShape(jsonSchema)) {
+    if (!hasObjectConstraints(jsonSchema)) {
         return;
     }
     const hasOwnObjectConstraints = Object.keys(jsonSchema).some((keyword) => JSON_SCHEMA_OBJECT_KEYWORDS.has(keyword));
@@ -941,7 +954,7 @@ function normalizeAnyOfFalseBranches(jsonSchema) {
  */
 function assertNoNestedSchemaIds(schema) {
     const visit = (value, path) => {
-        if (typeof value === 'boolean' || !isObject(value)) {
+        if (!isObject(value)) {
             return;
         }
         if (path.length > 0 && value.$id !== undefined) {
@@ -950,6 +963,7 @@ function assertNoNestedSchemaIds(schema) {
                 ' establishes a separate JSON Schema resource scope and cannot be represented in strict Structured Outputs.');
         }
         forEachJSONSchemaChild(value, path, (child, childPath) => {
+            // SAFETY: The schema-child visitor supplies only recognized object or boolean schema positions; the recursive helper validates their contents.
             visit(child, childPath);
         });
     };
@@ -1015,13 +1029,14 @@ function rewriteLocalRefsIntoMovedOneOfBranches(root) {
         return changed ? '#/' + parts.map(encodeJSONPointerTokenForURIFragment).join('/') : ref;
     };
     const rewriteRefs = (value) => {
-        if (typeof value === 'boolean' || !isObject(value)) {
+        if (!isObject(value)) {
             return;
         }
         if (typeof value.$ref === 'string') {
             value.$ref = rewriteRef(value.$ref);
         }
         forEachJSONSchemaChild(value, [], (child) => {
+            // SAFETY: The schema-child visitor supplies only recognized object or boolean schema positions; the recursive helper validates their contents.
             rewriteRefs(child);
         });
     };
@@ -1042,9 +1057,8 @@ function rewriteLocalRefsIntoFilteredAnyOfBranches(root) {
         let resolved = root;
         let changed = false;
         for (const [index, part] of originalParts.entries()) {
-            const resolvedRecord = typeof resolved === 'object' && resolved !== null && !Array.isArray(resolved)
-                ? resolved
-                : undefined;
+            // SAFETY: This is an object schema at this traversal point; the record view permits dynamic keyword access while individual values remain subject to schema checks.
+            const resolvedRecord = isObject(resolved) ? resolved : undefined;
             if (part === 'anyOf' &&
                 index < originalParts.length - 1 &&
                 resolvedRecord !== undefined &&
@@ -1082,13 +1096,14 @@ function rewriteLocalRefsIntoFilteredAnyOfBranches(root) {
         return changed ? '#/' + rewrittenParts.map(encodeJSONPointerTokenForURIFragment).join('/') : ref;
     };
     const rewriteRefs = (value) => {
-        if (typeof value === 'boolean' || !isObject(value)) {
+        if (!isObject(value)) {
             return;
         }
         if (typeof value.$ref === 'string') {
             value.$ref = rewriteRef(value.$ref);
         }
         forEachJSONSchemaChild(value, [], (child) => {
+            // SAFETY: The schema-child visitor supplies only recognized object or boolean schema positions; the recursive helper validates their contents.
             rewriteRefs(child);
         });
     };
@@ -1102,7 +1117,7 @@ function rewriteLocalRefsIntoFilteredAnyOfBranches(root) {
 function preserveAllOfRefTargets(root, rootOnly = false) {
     const refsToPreserve = new Set();
     const collectRefs = (value) => {
-        if (typeof value === 'boolean' || !isObject(value)) {
+        if (!isObject(value)) {
             return;
         }
         if (typeof value.$ref === 'string' && refTargetsAllOfBranch(root, value.$ref)) {
@@ -1112,6 +1127,7 @@ function preserveAllOfRefTargets(root, rootOnly = false) {
             }
         }
         forEachJSONSchemaChild(value, [], (child) => {
+            // SAFETY: The schema-child visitor supplies only recognized object or boolean schema positions; the recursive helper validates their contents.
             collectRefs(child);
         });
     };
@@ -1127,6 +1143,7 @@ function preserveAllOfRefTargets(root, rootOnly = false) {
     let aliasIndex = 0;
     for (const ref of refsToPreserve) {
         const target = resolveLocalRef(root, ref);
+        // oxlint-disable-next-line anti-slop/no-known-value-widening -- Local references require runtime schema validation even when the static return type is narrower.
         if (!isSchemaDefinition(target)) {
             if (rootOnly) {
                 continue;
@@ -1141,13 +1158,14 @@ function preserveAllOfRefTargets(root, rootOnly = false) {
         rewrittenRefs.set(ref, '#/$defs/' + escapeJSONPointerToken(alias));
     }
     const rewriteRefs = (value) => {
-        if (typeof value === 'boolean' || !isObject(value)) {
+        if (!isObject(value)) {
             return;
         }
         if (typeof value.$ref === 'string') {
             value.$ref = rewrittenRefs.get(value.$ref) ?? value.$ref;
         }
         forEachJSONSchemaChild(value, [], (child) => {
+            // SAFETY: The schema-child visitor supplies only recognized object or boolean schema positions; the recursive helper validates their contents.
             rewriteRefs(child);
         });
     };
@@ -1164,7 +1182,7 @@ function preserveDiscardedAllOfPropertyRefTargets(root, discardedPaths) {
     }
     const refsToPreserve = new Set();
     const collectRefs = (value) => {
-        if (typeof value === 'boolean' || !isObject(value)) {
+        if (!isObject(value)) {
             return;
         }
         if (typeof value.$ref === 'string') {
@@ -1176,6 +1194,7 @@ function preserveDiscardedAllOfPropertyRefTargets(root, discardedPaths) {
             }
         }
         forEachJSONSchemaChild(value, [], (child) => {
+            // SAFETY: The schema-child visitor supplies only recognized object or boolean schema positions; the recursive helper validates their contents.
             collectRefs(child);
         });
     };
@@ -1191,6 +1210,7 @@ function preserveDiscardedAllOfPropertyRefTargets(root, discardedPaths) {
     let aliasIndex = 0;
     for (const ref of refsToPreserve) {
         const target = resolveLocalRef(root, ref);
+        // oxlint-disable-next-line anti-slop/no-known-value-widening -- Validate referenced schema values at runtime before preserving them under generated definitions.
         if (!isSchemaDefinition(target)) {
             throw new Error('Local $ref cannot be preserved before allOf property removal: ' + JSON.stringify(ref));
         }
@@ -1202,20 +1222,21 @@ function preserveDiscardedAllOfPropertyRefTargets(root, discardedPaths) {
         rewrittenRefs.set(ref, '#/$defs/' + escapeJSONPointerToken(alias));
     }
     const rewriteRefs = (value) => {
-        if (typeof value === 'boolean' || !isObject(value)) {
+        if (!isObject(value)) {
             return;
         }
         if (typeof value.$ref === 'string') {
             value.$ref = rewrittenRefs.get(value.$ref) ?? value.$ref;
         }
         forEachJSONSchemaChild(value, [], (child) => {
+            // SAFETY: The schema-child visitor supplies only recognized object or boolean schema positions; the recursive helper validates their contents.
             rewriteRefs(child);
         });
     };
     rewriteRefs(root);
 }
 function validateRefSchemas(schema, path, root) {
-    if (typeof schema === 'boolean' || !isObject(schema)) {
+    if (!isObject(schema)) {
         return;
     }
     const ref = schema.$ref;
@@ -1227,6 +1248,7 @@ function validateRefSchemas(schema, path, root) {
             throw new Error(`External $ref at \`${path.join('/') || '<root>'}\` is not supported in strict Structured Outputs: ${JSON.stringify(ref)}`);
         }
         const resolved = resolveLocalRef(root, ref);
+        // oxlint-disable-next-line anti-slop/no-known-value-widening -- Untrusted local references must pass the runtime schema predicate before normalization.
         if (resolved === undefined || !isSchemaDefinition(resolved)) {
             throw new Error(`Local $ref at \`${path.join('/') || '<root>'}\` does not resolve to an object or boolean schema: ${JSON.stringify(ref)}`);
         }
@@ -1238,6 +1260,7 @@ function validateRefSchemas(schema, path, root) {
         }
     }
     forEachJSONSchemaChild(schema, path, (child, childPath) => {
+        // SAFETY: The schema-child visitor supplies only recognized object or boolean schema positions; the recursive helper validates their contents.
         validateRefSchemas(child, childPath, root);
     });
 }
@@ -1260,7 +1283,7 @@ function resolveObjectAllOfBranch(schema, root, normalizing) {
             }
             seenRefs.add(ref);
             const target = resolveLocalRef(root, ref);
-            if (typeof target === 'boolean' || !isObject(target)) {
+            if (!isObject(target)) {
                 return undefined;
             }
             const targetPath = parseLocalRef(ref);
@@ -1288,7 +1311,7 @@ function resolveObjectAllOfBranch(schema, root, normalizing) {
     }
 }
 function normalizeObjectAllOfBranches(schema, path, root, normalizing = new Set()) {
-    if (typeof schema === 'boolean' || !isObject(schema)) {
+    if (!isObject(schema)) {
         return;
     }
     if (normalizing.has(schema)) {
@@ -1298,6 +1321,7 @@ function normalizeObjectAllOfBranches(schema, path, root, normalizing = new Set(
     try {
         while (true) {
             forEachJSONSchemaChild(schema, path, (child, childPath) => {
+                // SAFETY: The schema-child visitor supplies only recognized object or boolean schema positions; the recursive helper validates their contents.
                 normalizeObjectAllOfBranches(child, childPath, root, normalizing);
             });
             // Intersections are associative, so normalize nested object
@@ -1337,13 +1361,14 @@ function normalizeObjectAllOfForExclusivity(schema, root) {
                 return undefined;
             }
             const branch = allOf[0];
-            if (typeof branch === 'boolean' || !isObject(branch)) {
+            if (!isObject(branch)) {
                 return undefined;
             }
             const siblings = { ...normalized };
             delete siblings.allOf;
             const flattened = structuredClone(branch);
             for (const keyword of Object.keys(normalized)) {
+                // SAFETY: Only an enumerated own keyword is deleted from this mutable schema object before installing its normalized replacement.
                 delete normalized[keyword];
             }
             assignSchema(normalized, flattened, siblings);
@@ -1380,23 +1405,23 @@ function mergeObjectAllOf(jsonSchema, path, root, normalizing = new Set()) {
         }
         return true;
     }
-    const parentHasObjectShape = hasObjectShapeWithoutAllOf(jsonSchema);
+    const parentIsMergeableObject = isMergeableObjectSchema(jsonSchema);
     const resolvedEntries = allOf.map((entry) => isObject(entry) ? resolveObjectAllOfBranch(entry, root, normalizing) : undefined);
     const objectBranches = resolvedEntries
         .map((entry) => entry?.schema)
-        .filter((entry) => entry !== undefined && hasObjectShapeWithoutAllOf(entry));
-    if (!parentHasObjectShape && objectBranches.length === 0) {
+        .filter((entry) => entry !== undefined && isMergeableObjectSchema(entry));
+    if (!parentIsMergeableObject && objectBranches.length === 0) {
         return false;
     }
     // A lone object branch with no object-valued parent is handled by the
     // existing safe single-allOf flattening path below.
-    if (!parentHasObjectShape && allOf.length === 1) {
+    if (!parentIsMergeableObject && allOf.length === 1) {
         return false;
     }
     const fail = () => {
         throw new Error(`Object allOf at \`${path.join('/') || '<root>'}\` cannot be merged without changing Draft 7 validation.`);
     };
-    if (!parentHasObjectShape &&
+    if (!parentIsMergeableObject &&
         ['additionalProperties', 'properties', 'required', 'type'].some((keyword) => keyword in jsonSchema)) {
         fail();
     }
@@ -1410,7 +1435,7 @@ function mergeObjectAllOf(jsonSchema, path, root, normalizing = new Set()) {
         }
     }
     const branches = [];
-    if (parentHasObjectShape) {
+    if (parentIsMergeableObject) {
         branches.push({ schema: jsonSchema, sourcePath: path });
     }
     for (const [index, entry] of allOf.entries()) {
@@ -1426,7 +1451,7 @@ function mergeObjectAllOf(jsonSchema, path, root, normalizing = new Set()) {
         // branch were preserved under stable root definitions before this merge,
         // so a valid definitions-only branch can now be discarded like an
         // annotation-only branch.
-        if (hasObjectShapeWithoutAllOf(branch)) {
+        if (isMergeableObjectSchema(branch)) {
             branches.push({
                 schema: branch,
                 sourcePath: branch === entry ? [...path, 'allOf', String(index)] : undefined,
@@ -1437,6 +1462,7 @@ function mergeObjectAllOf(jsonSchema, path, root, normalizing = new Set()) {
         }
     }
     const merged = {};
+    // SAFETY: This is an object schema at this traversal point; the record view permits dynamic keyword access while individual values remain subject to schema checks.
     for (const keyword of ['$defs', 'definitions']) {
         if (jsonSchema[keyword] !== undefined) {
             merged[keyword] = jsonSchema[keyword];
@@ -1445,10 +1471,13 @@ function mergeObjectAllOf(jsonSchema, path, root, normalizing = new Set()) {
     if (path.length === 0) {
         for (const keyword of JSON_SCHEMA_ROOT_METADATA_KEYWORDS) {
             if (keyword in jsonSchema) {
+                // SAFETY: Root annotation keywords are copied unchanged between schema objects; the record views preserve their unknown values.
+                // oxlint-disable-next-line anti-slop/no-known-value-widening -- Root annotation keywords are copied dynamically; JSONSchema has no index signature for extension fields. Metadata merging preserves arbitrary annotation/default values under the selected schema keywords.
                 merged[keyword] = jsonSchema[keyword];
             }
         }
     }
+    // SAFETY: This fresh null-prototype dictionary receives only JSON schema definitions while merging the validated property maps.
     const mergedProperties = Object.create(null);
     const mergedRequired = new Set();
     const closedPropertySets = [];
@@ -1466,6 +1495,7 @@ function mergeObjectAllOf(jsonSchema, path, root, normalizing = new Set()) {
             // first value (the outer schema, then earlier branches) instead of
             // rejecting an otherwise exactly mergeable intersection.
             if (!(keyword in merged)) {
+                // SAFETY: These annotation keywords are copied unchanged from the validated branch; arbitrary values are preserved without narrowing.
                 merged[keyword] = schema[keyword];
             }
         }
@@ -1484,6 +1514,7 @@ function mergeObjectAllOf(jsonSchema, path, root, normalizing = new Set()) {
             if (keyword === 'allOf' && branch === jsonSchema) {
                 continue;
             }
+            // SAFETY: This is an object schema at this traversal point; the record view permits dynamic keyword access while individual values remain subject to schema checks.
             if ((keyword === '$defs' || keyword === 'definitions') &&
                 isObject(branch[keyword])) {
                 continue;
@@ -1568,6 +1599,7 @@ function mergeObjectAllOf(jsonSchema, path, root, normalizing = new Set()) {
         if (collapsesToNull) {
             merged.type = 'null';
             for (const keyword of Object.keys(jsonSchema)) {
+                // SAFETY: Only an enumerated own keyword is deleted from this mutable schema object before installing its normalized replacement.
                 delete jsonSchema[keyword];
             }
             assignSchema(jsonSchema, merged);
@@ -1597,18 +1629,20 @@ function mergeObjectAllOf(jsonSchema, path, root, normalizing = new Set()) {
         merged.additionalProperties = false;
     }
     for (const keyword of Object.keys(jsonSchema)) {
+        // SAFETY: Only an enumerated own keyword is deleted from this mutable schema object before installing its normalized replacement.
         delete jsonSchema[keyword];
     }
     assignSchema(jsonSchema, merged);
     return true;
 }
-function hasObjectShapeWithoutAllOf(schema) {
+function isMergeableObjectSchema(schema) {
     if (schema.type !== undefined) {
         return isMergeableObjectType(schema.type);
     }
     return Object.keys(schema).some((keyword) => JSON_SCHEMA_OBJECT_KEYWORDS.has(keyword));
 }
 function hasOnlyNeutralAllOfBranchKeywords(schema) {
+    // SAFETY: This is an object schema at this traversal point; the record view permits dynamic keyword access while individual values remain subject to schema checks.
     const schemaRecord = schema;
     return Object.keys(schema).every((keyword) => JSON_SCHEMA_ANNOTATION_KEYWORDS.has(keyword) ||
         ((keyword === '$defs' || keyword === 'definitions') && isObject(schemaRecord[keyword])));
@@ -1630,7 +1664,9 @@ function schemasEqual(left, right) {
     if (typeof left !== 'object' || left === null || typeof right !== 'object' || right === null) {
         return false;
     }
+    // SAFETY: This is an object schema at this traversal point; the record view permits dynamic keyword access while individual values remain subject to schema checks.
     const leftRecord = left;
+    // SAFETY: This is an object schema at this traversal point; the record view permits dynamic keyword access while individual values remain subject to schema checks.
     const rightRecord = right;
     const leftKeys = Object.keys(leftRecord);
     const rightKeys = Object.keys(rightRecord);