fix(js): deepFreeze recurses below already-frozen parents

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

js/solutions/util.js

@@ -18,12 +18,13 @@ export const compose = (...fns) => (x) => fns.reduceRight((acc, f) => f(acc), x)
 /**
  * Freeze `obj` and everything reachable from it, then return it.
  * Freezing is the one deliberate "mutation" here: it makes later accidental mutation throw.
+ * We recurse even into children that are already frozen (a frozen parent can still hold
+ * unfrozen children). `ancestors` is the path from the root to `obj`; passing it down
+ * (instead of keeping a shared "seen" set) stops cyclic structures without any mutable state.
  */
-export const deepFreeze = (obj) => {
+export const deepFreeze = (obj, ancestors = []) => {
+  if (obj === null || typeof obj !== 'object' || ancestors.includes(obj)) return obj
   Object.freeze(obj)
-  // Freezing before recursing means cyclic structures stop at the already-frozen node.
+  Object.values(obj).forEach((v) => deepFreeze(v, [...ancestors, obj]))
-  Object.values(obj).forEach((v) => {
-    if (v !== null && typeof v === 'object' && !Object.isFrozen(v)) deepFreeze(v)
-  })
   return obj
 }

js/src/util.js

@@ -15,5 +15,5 @@ export const pipe = (x, ...fns) => todo('m01')
 /** `compose(f, g)(x)` is `f(g(x))`: functions applied right to left. */
 export const compose = (...fns) => todo('m01')
 
-/** Freeze `obj` and everything reachable from it, then return it (same object). */
+/** Freeze `obj` and everything reachable from it (even below already-frozen parents; cycles are fine), then return it (same object). */
 export const deepFreeze = (obj) => todo('m01')

js/test/m01-util.test.js

@@ -45,3 +45,13 @@ test('m01 deepFreeze returns the same object it was given', () => {
   const o = {}
   assert.equal(deepFreeze(o), o)
 })
+test('m01 deepFreeze reaches unfrozen children of an already-frozen parent', () => {
+  const o = deepFreeze({ a: Object.freeze({ b: { c: 1 } }) })
+  assert.ok(Object.isFrozen(o.a.b))
+})
+test('m01 deepFreeze handles cyclic objects', () => {
+  const o = { child: {} }
+  o.child.parent = o
+  deepFreeze(o)
+  assert.ok(Object.isFrozen(o) && Object.isFrozen(o.child))
+})