Can deepComputed signals work with unknown key names?

[jvanderen1]

I am a bit confused on how deepComputed signals work with unknown keys. Should you be able to access inner object properties as a signal with unknown keys?

Example

Say I have this deepComputed signal defined inside this signal store:

interface Student {
  id: string;
  name: string;
  grade: string;
}

interface State {
  students: {
    [id: string]: Student;
  };
}

const INITIAL_STATE = {
  students: {},
} as const satisfies State;

/**
 * Example Signal store for a school.
 */
export const SchoolStore = signalStore(
  {providedIn: 'root'},
  withState<State>(INITIAL_STATE),
  withComputed((store) => ({
    // Object is grouped together by unknown keys
    studentsByGrade: deepComputed<Readonly<Record<string, readonly Student[]>>>(
      () =>
        Object.values(store.students()).reduce<Record<string, Student[]>>(
          (acc, student) => {
            const grade = student.grade;
            acc[grade] ??= [];
            acc[grade].push(student);
            return acc;
          },
          {},
        ),
    ),
  })),
  withMethods((store) => ({
    addStudent(student: Student) {
      patchState(store, (state) => ({
        students: {...state.students, [student.id]: student},
      }));
    },
    getStudentsByGrade(grade: string) {
      return computed<readonly Student[]>(
        () => store.studentsByGrade[grade]?.() ?? [], // Typescript error here.
      );
    },
  })),
);

The error I get during compilation is that:

Element implicitly has an 'any' type because expression of type 'string' can't be used to index type 'Signal<Record<string, readonly Student[]>>'.
  No index signature with a parameter of type 'string' was found on type 'Signal<Record<string, readonly Student[]>>'.

It seems like the DeepSignal got converted to a regular Signal. Is there a way around this?

[jdegand]

Signals are created lazily for known keys only, meaning they’re only wrapped as signals once they're accessed and confirmed to exist. If you want every possible property — even undefined or unknown ones — to behave like a signal from the start, you'd need to fundamentally change how toDeepSignal works. That would involve returning a signal for every property access, regardless of whether the key exists in the object at that moment. This improves ergonomics but comes with trade-offs in type safety, performance, and runtime guarantees.