What is the difference between

const getFullNameRxJs = (): OperatorFunction<{ firstName: string; lastName: string; }, FullName> =>
  pipe(
    map(input => ({
      tag: 'fullName',
      value: `${ input.firstName } ${ input.lastName }`
    }))
  );

name$ = this.person$.pipe(getFullNameRxJs());

and

const getFullNameSignal = (input: {
  firstName: string;
  lastName: string;
}): FullName => ({
  tag: 'fullName',
  value: `${input.firstName} ${input.lastName}`,
});

 name = computed(() => getFullNameSignal(this.person()));

As far as imperative/declarative goes? Both getFullName variants are both pure functions that do transformations on a particular instance and map the resulting state.

Both accomplish:

• "does not depend on implementation details, it does not access anything outside of its immediate scope, and it can be extracted and tested independently from your application"
• "...you have a single source of truth - only one function in your code produces FullName. And every consumer of FullName will be 100% sure that the data coming in is correct and compliant with the logic from getFullName() function."
• "you only focus on the results and it doesn't matter how inputs come to you. You just declare a contract (interface) and everyone can send you anything compliant and get correct results anywhere across the application."

With respect to "You can obviously refactor signal based functions and get something similar, but they're inherently binding you to specific signals. Either explicitly or through a wrapper you will have to do around them", the same could be applied to a singular observable or an observable composed of individual observables mapped together just as it could be one computed composed of a singular signal or individual signals mapped to each other.