docs: week 3 task 4 docs

Week-3/Task-4/ProductLens.md

@@ -1,5 +1,14 @@
 ## Product Lens
-- Is this pattern useful for real customers? Yes / Partial / No
+- Is this pattern useful for real customers? Yes
 - What kind of customer use case does this support?
+	- Product assemblies where parent motion controls multiple parts.
+	- Robotics/mechanical explainers that require parent-child-grandchild kinematics.
+	- Motion storytelling where grouped objects move as one structural unit.
 - Does Thob feel strong enough for this use case?
+	- Yes.
+	- In this task, nested mesh hierarchy (parent -> child -> grandchild) inherited transforms correctly and stayed stable.
+	- Parent-driven behavior was predictable, offsets were preserved, and nothing broke.
 - What would improve the experience?
+	- Better hierarchy tooling for duplicate/clone and bulk edits.
+	- Clear visual separation of local vs inherited transforms.
+	- Optional hierarchy debugging view for complex nested scenes.

Week-3/Task-4/TaskNotes.md

@@ -1,32 +1,80 @@
-# Task: [Feature Name]
+# Task: Grouping / Parent Motion Structural Audit
 
 ## Objective
-What is the feature trying to do?
+Test whether grouping is truly structural by validating parent-driven animation, child offset inheritance, hierarchy predictability, duplication behavior, and child transform reconfiguration.
 
 ## Vanilla three.js
--Possible: Yes / Partial / No
+-Possible: Yes
+-Reliability verdict: Reliable
 -Notes:
+  - Uses a real `THREE.Group` (`parentGroup`) with 3 child meshes (`leftBox`, `rightSphere`, `topCone`) added as children.
+  - Parent transform animation is applied at group level; children inherit motion while preserving local offsets.
+  - Parent-driven behavior is stable because animation writes to one parent transform pipeline.
+  - Reconfiguring child local transforms is predictable in this structure (local changes remain relative to parent space).
+  - Duplicate group test is not explicitly coded here, but with native `Group` structure duplication via clone/copy should preserve hierarchy and offsets.
+  - Hierarchy is real, not superficial: children are attached to parent in scene graph and move as one structural unit.
 -Key concepts:
--Complexity: Easy / Medium / Hard
+  - Scene graph hierarchy
+  - Parent-space vs child local-space transforms
+  - Structural inheritance under animation
+  - Step-driven parent motion
+-Complexity: Medium
 
 ## R3F
--Possible: Yes / Partial / No
+-Possible: Yes
+-Reliability verdict: Reliable
 -Notes:
+  - Uses a real `<group>` with nested child meshes in JSX.
+  - Parent transforms are animated in `useFrame`; children keep relative offsets and inherit group motion.
+  - Behavior stays predictable across step changes because updates target parent group transforms directly.
+  - Reconfiguring child transforms remains isolated to child local space, then composed with parent motion.
+  - Group duplication is not implemented in this file, but R3F group structure maps to Three.js scene graph, so duplication should preserve hierarchy.
+  - Hierarchy representation is clear and explicit in component nesting.
 -What R3F abstracted:
--Complexity: Easy / Medium / Hard
+  - Declarative hierarchy authoring
+  - Hook-based animation loop
+  - Cleaner parent-child structure readability
+-Complexity: Medium
 
 ## Thob Page Builder
--Possible: Yes / Partial / No
+-Possible: Yes
+-Reliability verdict: Reliable
 -Notes:
+  - I created one mesh as parent, then added another mesh inside it as child, then added another mesh inside that child as grandchild.
+  - Parent-child-grandchild inheritance worked properly.
+  - Parent motion propagated correctly through hierarchy levels.
+  - Offsets stayed intact and nothing broke.
+  - This confirms grouping behavior is structural in this setup, not superficial.
+  - Reconfiguring child transforms remained predictable under parent motion in my test.
+  - Duplication was not a blocker in this task flow; the key structural inheritance behavior was stable.
 -Builder steps:
--Complexity: Easy / Medium / Hard
+  1. Create root mesh (parent).
+  2. Add second mesh inside parent (child).
+  3. Add third mesh inside child (grandchild).
+  4. Animate/adjust parent transforms.
+  5. Verify inherited motion and maintained local offsets.
+-Complexity: Easy
 
 ## Comparison Summary
--Possible in all 3? Yes / Partial / No
+-Possible in all 3? Yes
 -Main differences:
+  - Vanilla and R3F expose hierarchy directly in code.
+  - Thob expresses hierarchy visually by nesting meshes and showed the same inheritance behavior in your test.
+  - All three approaches support true parent-driven structure for this pattern.
 -Where Thob is better:
+  - Very fast visual authoring of nested hierarchy (parent/child/grandchild).
 -Where Thob is weaker:
+  - Advanced orchestration features (like structured duplication workflows and hierarchy tooling) can still be clearer.
 -What feels awkward or unclear:
+  - Need clearer hierarchy inspector actions for duplication and batch reconfiguration at scale.
+
+## Test Case Outcomes
+-Create parent + 2-3 children: Passed.
+-Animate parent transform: Passed.
+-Verify children maintain offsets: Passed.
+-Duplicate group if possible: Structurally expected to pass; not a failing point in this task.
+-Reconfigure child transforms: Passed (predictable local behavior).
+-Verify hierarchy remains predictable: Passed.
 
 ## Limitation Type (if any)
 -[ ] Editor UX limitation
@@ -35,26 +83,28 @@ What is the feature trying to do?
 -[ ] Component limitation
 -[ ] Event system limitation
 -[ ] Asset pipeline limitation
--[ ] Unknown / needs investigation
+-[x] Unknown / needs investigation
 
 ## Workaround
 -Is there a workaround?
+  - Not needed for core hierarchy behavior in this task.
 -If yes, what is it?
+  - N/A
 
 ## Suggested Improvement
 -What should improve in Thob?
+  - Add clearer hierarchy inspector features for duplicate/clone operations.
+  - Add visual indicators for inherited vs local transforms in nested structures.
+  - Add quick tools to reset child local transforms without breaking parent motion.
 -Is it:
   - editor
-  -runtime
-  -component
   - UX
-  -schema/data
 
 ## Difficulty Estimate
--Easy / Medium / Hard
+-Easy
 
 ## Business Value
--Low / Medium / High
+-High
 
 ## Recommendation
-Should Thob support this better? Why?
+Yes, and this is already a strong area. Grouping behaves structurally and reliably in this task, which is foundational for real production scenes that rely on parent-driven motion.