Fix

packages/example/src/routes/tests.tsx

@@ -11,11 +11,7 @@ export const Route = createFileRoute("/tests")({
 
 function RouteComponent() {
     const deepRef = R.useRef({ value: "poulet" })
-    const deepValueRef = R.useSubRefFromGetSet(
+    const deepValueRef = R.useSubRefFromPath(deepRef, ["value"])
-        deepRef,
-        b => b.value,
-        (b, a) => ({ ...b, value: a }),
-    )
 
     // const value = R.useMemoScoped(Effect.addFinalizer(() => Console.log("cleanup")).pipe(
     //     Effect.andThen(makeUuid4),

packages/reffuse/src/ReffuseNamespace.ts

@@ -2,7 +2,7 @@ import { type Context, Effect, ExecutionStrategy, Exit, type Fiber, type Layer,
 import * as React from "react"
 import * as ReffuseContext from "./ReffuseContext.js"
 import * as ReffuseRuntime from "./ReffuseRuntime.js"
-import { SetStateAction, SubscriptionSubRef } from "./types/index.js"
+import { type PropertyPath, SetStateAction, SubscriptionSubRef } from "./types/index.js"
 
 
 export interface RenderOptions {
@@ -396,6 +396,17 @@ export abstract class ReffuseNamespace<R> {
         )
     }
 
+    useSubRefFromPath<B, const P extends PropertyPath.Paths<B>, R>(
+        this: ReffuseNamespace<R>,
+        parent: SubscriptionRef.SubscriptionRef<B>,
+        path: P,
+    ): SubscriptionSubRef.SubscriptionSubRef<PropertyPath.ValueFromPath<B, P>, B> {
+        return React.useMemo(
+            () => SubscriptionSubRef.makeFromPath(parent, path),
+            [parent],
+        )
+    }
+
     useSubscribeRefs<
         const Refs extends readonly SubscriptionRef.SubscriptionRef<any>[],
         R,

packages/reffuse/src/types/PropertyPath.ts

@@ -0,0 +1,93 @@
+import { Array, Option, Predicate } from "effect"
+
+
+export type Paths<T> = [] | (
+    T extends readonly any[] ? ArrayPaths<T> :
+    T extends object ? ObjectPaths<T> :
+    never
+)
+
+export type ArrayPaths<T extends readonly any[]> = {
+    [K in keyof T as K extends number ? K : never]:
+        | [K]
+        | [K, ...Paths<T[K]>]
+} extends infer O
+    ? O[keyof O]
+    : never
+
+export type ObjectPaths<T extends object> = {
+    [K in keyof T as K extends string | number | symbol ? K : never]:
+        | [K]
+        | [K, ...Paths<T[K]>]
+} extends infer O
+    ? O[keyof O]
+    : never
+
+export type ValueFromPath<T, P extends any[]> = P extends [infer Head, ...infer Tail]
+    ? Head extends keyof T
+        ? ValueFromPath<T[Head], Tail>
+        : T extends readonly any[]
+            ? Head extends number
+                ? ValueFromPath<T[number], Tail>
+                : never
+            : never
+    : T
+
+export type AnyKey = string | number | symbol
+export type AnyPath = readonly AnyKey[]
+
+
+export const unsafeGet = <T, const P extends Paths<T>>(
+    parent: T,
+    path: P,
+): ValueFromPath<T, P> => (
+    path.reduce((acc: any, key: any) => acc?.[key], parent)
+)
+
+export const get = <T, const P extends Paths<T>>(
+    parent: T,
+    path: P,
+): Option.Option<ValueFromPath<T, P>> => path.reduce(
+    (acc: Option.Option<any>, key: any): Option.Option<any> => Option.isSome(acc)
+        ? Predicate.hasProperty(acc.value, key)
+            ? Option.some(acc.value[key])
+            : Option.none()
+        : acc,
+
+    Option.some(parent),
+)
+
+export const immutableSet = <T, const P extends Paths<T>>(
+    parent: T,
+    path: P,
+    value: ValueFromPath<T, P>,
+): Option.Option<T> => {
+    const key = Array.head(path as AnyPath)
+    if (Option.isNone(key))
+        return Option.some(value as T)
+    if (!Predicate.hasProperty(parent, key.value))
+        return Option.none()
+
+    const child = immutableSet<any, any>(parent[key.value], Option.getOrThrow(Array.tail(path as AnyPath)), value)
+    if (Option.isNone(child))
+        return child
+
+    if (Array.isArray(parent))
+        return typeof key.value === "number"
+            ? Option.some([
+                ...parent.slice(0, key.value),
+                child.value,
+                ...parent.slice(key.value + 1),
+            ] as T)
+            : Option.none()
+
+    if (typeof parent === "object")
+        return Option.some(
+            Object.assign(
+                Object.create(Object.getPrototypeOf(parent)),
+                { ...parent, [key.value]: child.value },
+            )
+        )
+
+    return Option.none()
+}

packages/reffuse/src/types/SubscriptionSubRef.ts

@@ -1,4 +1,5 @@
-import { Effect, Effectable, Readable, Ref, Stream, Subscribable, SubscriptionRef, SynchronizedRef, type Types, type Unify } from "effect"
+import { Effect, Effectable, Option, Readable, Ref, Stream, Subscribable, SubscriptionRef, SynchronizedRef, type Types, type Unify } from "effect"
+import * as PropertyPath from "./PropertyPath.js"
 
 
 export const SubscriptionSubRefTypeId: unique symbol = Symbol.for("reffuse/types/SubscriptionSubRef")
@@ -87,3 +88,12 @@ export const makeFromGetSet = <A, B>(
     getter: (parentValue: B) => A,
     setter: (parentValue: B, value: A) => B,
 ): SubscriptionSubRef<A, B> => new SubscriptionSubRefImpl(parent, getter, setter)
+
+export const makeFromPath = <B, const P extends PropertyPath.Paths<B>>(
+    parent: SubscriptionRef.SubscriptionRef<B>,
+    path: P,
+): SubscriptionSubRef<PropertyPath.ValueFromPath<B, P>, B> => new SubscriptionSubRefImpl(
+    parent,
+    parentValue => Option.getOrThrow(PropertyPath.get(parentValue, path)),
+    (parentValue, value) => Option.getOrThrow(PropertyPath.immutableSet(parentValue, path, value)),
+)

packages/reffuse/src/types/index.ts

@@ -1,2 +1,3 @@
+export * as PropertyPath from "./PropertyPath.js"
 export * as SetStateAction from "./SetStateAction.js"
 export * as SubscriptionSubRef from "./SubscriptionSubRef.js"