function compileService(meta, resolveForwardRefs) {
  const def = new DefinitionMap();
  def.set('token', meta.type.value);
  def.set('factory', meta.factory === undefined
    ? delegateToFactory(meta.type.value, meta.type.value, resolveForwardRefs)
    : arrowFn([], meta.factory.callFn([]), DYNAMIC_TYPE));
  if (meta.autoProvided === false) {
    def.set('autoProvided', literal(false));
  }
  const expression = importExpr(Identifiers.defineService).callFn([def.toLiteralMap()], undefined, true);
  return { expression, type: createInjectableType(), statements: [] };
}

function ɵɵdefineService(opts) {
  return {
    token: opts.token,
    providedIn: opts.autoProvided === false ? null : 'root',
    factory: opts.factory,
    value: undefined
  };
}

interface Service {
    autoProvided?: boolean;
    factory?: () => unknown;
}

// 22 より前
@Injectable({
  providedIn: 'root',
  useFactory: (config: AppConfig) => new PriceFormatter(config.locale),
  deps: [AppConfig],
})
export abstract class PriceFormatter { /* ... */ }

// @Service() で書くと
@Service({
  factory: () => new PriceFormatter(inject(AppConfig).locale),
})
export abstract class PriceFormatter { /* ... */ }

<T>(options: {
    autoProvided?: true;
    factory: () => T;
}): <C extends Type$1<unknown> | AbstractType<unknown>>(target: C) => C extends Type$1<unknown>
    ? Type$1<T>
    : abstract new (...args: any[]) => T;

@Service({
  factory: () => inject(HttpBackedCatalog),
})
export class Catalog {
  // ここに書いたメソッドは inject(Catalog) の型には現れない
  findById(id: string): Item | undefined { /* ... */ }
}

@Reviewer: `factory` で `HttpBackedCatalog` を返しているため、`inject(Catalog)` の型は `HttpBackedCatalog` になります。この `Catalog` クラスに書かれている `findById` は型の上から消えるので、呼んでいる箇所があれば今は通っていないはずです。トークンだけを `Catalog` に残す意図でしたら、本体の実装を `HttpBackedCatalog` 側へ移して `Catalog` は抽象クラスにしてください。

@Service()
export class WizardState { /* ... */ }

@Component({
  selector: 'app-wizard',
  providers: [WizardState],  // ここで1つ作られる
  // ...
})
export class WizardComponent {
  readonly state = inject(WizardState);
}

if (isTypeProvider(provider)) {
    const unwrappedProvider = resolveForwardRef(provider);
    return getFactoryDef(unwrappedProvider) || injectableDefOrInjectorDefFactory(unwrappedProvider);
}

@Reviewer: `WizardState` は `@Service()` なので root にも登録されています。この `providers` で作られるのはコンポーネント専用の2つ目で、`WizardComponent` の外から `inject(WizardState)` している箇所があるとそちらは root 側を見ます。この画面だけで使う状態でしたら `@Service({autoProvided: false})` に変えてください。書き忘れた箇所が `NullInjectorError` で落ちるようになります。

function getInjectableDef(type) {
  return getOwnDefinition(type, NG_PROV_DEF);
}
function getOwnDefinition(type, field) {
  return Object.hasOwn(type, field) && type[field] || null;
}

function getInheritedInjectableDef(type) {
  const def = type?.[NG_PROV_DEF] ?? null;
  if (def) {
    ngDevMode && console.warn(`DEPRECATED: DI is instantiating a token "${type.name}" that inherits its @Injectable decorator but does not provide one itself.\n` + `This will become an error in a future version of Angular. Please add @Injectable() to the "${type.name}" class.`);
    return def;
  } else {
    return null;
  }
}

 * NOTE: To enable lazy loading, the injected service must be auto-provided. This means it should be decorated with either `@Injectable({providedIn: 'root'})` or `@Service()`.

function injectAsync(loader, options) {
  if (ngDevMode) {
    assertInInjectionContext(injectAsync);
  }
  const injector = inject(Injector);
  let loadedPromise = null;
  const load = () => {
    if (!loadedPromise) {
      loadedPromise = loader();
    }
    return loadedPromise;
  };
  if (options?.prefetch) {
    options.prefetch().then(() => load()).catch(() => {});
  }
  return () => load().then(loadedToken => injector.get(maybeUnwrapDefaultExport(loadedToken)));
}

@Reviewer: `ReportExporter` は `autoProvided: false` で、`ReportPageComponent` の `providers` に入っています。`injectAsync` は読み込みが終わったあとに `injector.get()` を呼ぶため、登録が無いインジェクターから呼ぶと、この画面を開いた時点ではなく出力ボタンを押したあとに Promise が拒否されます。遅延させたいのであれば自動で登録される側にするか、`injectAsync` を外して通常の `inject()` にしてください。