openai 7.15.0 → 7.17.0

package/lib/transform.mjs

@@ -99,6 +99,7 @@ function assignSchema(target, ...sources) {
  * participate.
  */
 export 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) {
@@ -171,10 +172,11 @@ export 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) {
@@ -182,6 +184,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);
     });
 }
@@ -257,6 +260,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];
             }
         }
@@ -275,6 +279,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];
@@ -313,12 +318,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];
@@ -347,7 +353,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);
@@ -374,6 +380,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];
@@ -438,13 +445,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);
         });
     };
@@ -472,13 +480,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);
     });
 }
@@ -569,7 +578,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 (!hasOwn(jsonSchema, 'additionalProperties')) {
             jsonSchema.additionalProperties = false;
         }
@@ -583,7 +592,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) || !hasOwn(properties, key)) {
                 throw new Error(`Object schema at \`${path.join('/') || '<root>'}\` requires property \`${key}\` but does not declare it in \`properties\`.`);
@@ -630,6 +639,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
@@ -653,6 +663,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
@@ -692,6 +703,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)) {
@@ -771,7 +783,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) {
@@ -799,7 +811,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) {
@@ -837,6 +849,7 @@ export 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
@@ -865,7 +878,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')) ||
@@ -887,7 +900,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));
@@ -932,7 +945,7 @@ function normalizeAnyOfFalseBranches(jsonSchema) {
  */
 export function assertNoNestedSchemaIds(schema) {
     const visit = (value, path) => {
-        if (typeof value === 'boolean' || !isObject(value)) {
+        if (!isObject(value)) {
             return;
         }
         if (path.length > 0 && value.$id !== undefined) {
@@ -941,6 +954,7 @@ export 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);
         });
     };
@@ -1006,13 +1020,14 @@ export 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);
         });
     };
@@ -1033,9 +1048,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 &&
@@ -1073,13 +1087,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);
         });
     };
@@ -1093,7 +1108,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)) {
@@ -1103,6 +1118,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);
         });
     };
@@ -1118,6 +1134,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;
@@ -1132,13 +1149,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);
         });
     };
@@ -1155,7 +1173,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') {
@@ -1167,6 +1185,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);
         });
     };
@@ -1182,6 +1201,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));
         }
@@ -1193,20 +1213,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;
@@ -1218,6 +1239,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)}`);
         }
@@ -1229,6 +1251,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);
     });
 }
@@ -1251,7 +1274,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);
@@ -1279,7 +1302,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)) {
@@ -1289,6 +1312,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
@@ -1328,13 +1352,14 @@ export 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);
@@ -1371,23 +1396,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();
     }
@@ -1401,7 +1426,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()) {
@@ -1417,7 +1442,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,
@@ -1428,6 +1453,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];
@@ -1436,10 +1462,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 = [];
@@ -1457,6 +1486,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];
             }
         }
@@ -1475,6 +1505,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;
@@ -1559,6 +1590,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);
@@ -1588,18 +1620,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])));
@@ -1621,7 +1655,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);