alepha 0.19.1 → 0.19.3

package/src/react/router/providers/ReactPageProvider.ts

@@ -2,7 +2,7 @@ import {
   $atom,
   $hook,
   $inject,
-  $use,
+  $state,
   Alepha,
   AlephaError,
   type TSchema,
@@ -60,7 +60,7 @@ export const reactPageOptions = $atom({
 export class ReactPageProvider {
   protected readonly dateTimeProvider = $inject(DateTimeProvider);
   protected readonly log = $logger();
-  protected readonly options = $use(reactPageOptions);
+  protected readonly options = $state(reactPageOptions);
   protected readonly alepha = $inject(Alepha);
   protected readonly pages: PageRoute[] = [];
   protected nextIdCursor = 0;

package/src/react/router/providers/ReactServerProvider.ts

@@ -4,7 +4,7 @@ import {
   $env,
   $hook,
   $inject,
-  $use,
+  $state,
   Alepha,
   type Middleware,
   OPTIONS,
@@ -72,8 +72,8 @@ export class ReactServerProvider {
    */
   protected hasServerLinksProvider = false;
 
-  protected readonly options = $use(reactServerOptions);
-  protected readonly pageOptions = $use(reactPageOptions);
+  protected readonly options = $state(reactServerOptions);
+  protected readonly pageOptions = $state(reactPageOptions);
 
   /**
    * Configure the React server provider.

package/src/redis/{providers → __tests__}/BunRedisProvider.bun.spec.ts

@@ -1,10 +1,10 @@
 import { afterAll, beforeAll, describe, expect, it } from "bun:test";
 import { randomUUID } from "node:crypto";
 import { Alepha } from "alepha";
-import { BunRedisProvider } from "./BunRedisProvider.ts";
-import { BunRedisSubscriberProvider } from "./BunRedisSubscriberProvider.ts";
-import { RedisProvider } from "./RedisProvider.ts";
-import { RedisSubscriberProvider } from "./RedisSubscriberProvider.ts";
+import { BunRedisProvider } from "../providers/BunRedisProvider.ts";
+import { BunRedisSubscriberProvider } from "../providers/BunRedisSubscriberProvider.ts";
+import { RedisProvider } from "../providers/RedisProvider.ts";
+import { RedisSubscriberProvider } from "../providers/RedisSubscriberProvider.ts";
 
 // -------------------------------------------------------------------------------------------------------------------
 

package/src/retry/{primitives → __tests__}/$retry.middleware.spec.ts

@@ -1,6 +1,6 @@
 import { $pipeline, Alepha } from "alepha";
 import { describe, test } from "vitest";
-import { $retry } from "./$retry.ts";
+import { $retry } from "../primitives/$retry.ts";
 
 describe("$retry middleware", () => {
   test("retries handler on failure", async ({ expect }) => {

package/src/router/{TemplatedPathParser.spec.ts → __tests__/TemplatedPathParser.spec.ts}

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { TemplatedPathParser } from "./TemplatedPathParser.ts";
+import { TemplatedPathParser } from "../TemplatedPathParser.ts";
 
 describe("TemplatedPathParser", () => {
   describe("normalize", () => {

package/src/scheduler/primitives/$scheduler.ts

@@ -2,7 +2,7 @@ import {
   $atom,
   $inject,
   $pipeline,
-  $use,
+  $state,
   Alepha,
   type Async,
   createPrimitive,
@@ -93,7 +93,7 @@ declare module "alepha" {
 
 export class SchedulerPrimitive extends Primitive<SchedulerPrimitiveOptions> {
   protected readonly log = $logger();
-  protected readonly settings = $use(schedulerOptions);
+  protected readonly settings = $state(schedulerOptions);
   protected readonly alepha = $inject(Alepha);
   protected readonly dateTimeProvider = $inject(DateTimeProvider);
   protected readonly cronProvider = $inject(CronProvider);

package/src/security/{primitives → __tests__}/$secure-browser.spec.ts

@@ -1,7 +1,7 @@
 import { $pipeline, Alepha } from "alepha";
 import { describe, it } from "vitest";
 import { currentUserAtom } from "../atoms/currentUserAtom.ts";
-import { $secure } from "./$secure.browser.ts";
+import { $secure } from "../primitives/$secure.browser.ts";
 
 describe("$secure (browser)", () => {
   describe("authentication", () => {

package/src/security/{primitives → __tests__}/$secure.spec.ts

@@ -3,8 +3,8 @@ import { ForbiddenError, UnauthorizedError } from "alepha/server";
 import { describe, test } from "vitest";
 import { currentUserAtom } from "../atoms/currentUserAtom.ts";
 import type { UserAccountToken } from "../interfaces/UserAccountToken.ts";
+import { $secure } from "../primitives/$secure.ts";
 import { SecurityProvider } from "../providers/SecurityProvider.ts";
-import { $secure } from "./$secure.ts";
 
 // -----------------------------------------------------------------------------------------------------------------
 // Test helpers

package/src/security/primitives/$issuer.ts

@@ -311,7 +311,7 @@ export class IssuerPrimitive extends Primitive<IssuerPrimitiveOptions> {
         preferred_username: user.username,
         picture: user.picture,
         // our claims
-        organizations: user.organizations,
+        organization: user.organization,
         roles: user.roles,
       },
       this.name,

package/src/security/providers/JwtProvider.ts

@@ -37,27 +37,23 @@ export class JwtProvider {
    */
   public setKeyLoader(name: string, secretKeyOrJwks: string | JSONWebKeySet) {
     if (typeof secretKeyOrJwks === "object") {
-      this.log.info(
-        `will verify JWTs from key '${name}' with JWKS object (x${secretKeyOrJwks.keys.length})`,
-      );
+      this.log.debug(`will verify JWTs from key '${name}' with JWKS object`);
       this.keystore.push({
         name,
         keyLoader: createLocalJWKSet(secretKeyOrJwks),
       });
     } else if (this.isSecretKey(secretKeyOrJwks)) {
       const secretKey = this.encoder.encode(secretKeyOrJwks);
-      this.log.info(
-        `will verify JWTs from issuer '${name}' with secret key (${secretKey.length} bytes)`,
-      );
+      this.log.debug(`will verify JWTs from issuer '${name}' with secret key`);
       this.keystore.push({
         name,
         secretKey: secretKeyOrJwks,
         keyLoader: () => Promise.resolve(createSecretKey(secretKey)),
       });
     } else {
-      this.log.info(
-        `will verify JWTs from issuer '${name}' with JWKS ${secretKeyOrJwks}`,
-      );
+      this.log.debug(`will verify JWTs from issuer '${name}' with JWKS`, {
+        url: secretKeyOrJwks,
+      });
       this.keystore.push({
         name,
         keyLoader: createRemoteJWKSet(new URL(secretKeyOrJwks)),
@@ -187,7 +183,7 @@ export interface ExtendedJWTPayload extends JWTPayload {
   name?: string;
   roles?: string[];
   email?: string;
-  organizations?: string[];
+  organization?: string;
   // keycloak specific
   realm_access?: { roles: string[] };
 }

package/src/security/providers/SecurityProvider.ts

@@ -295,7 +295,7 @@ export class SecurityProvider {
     const username = this.getUsernameFromPayload(payload);
     const picture = this.getPictureFromPayload(payload);
     const name = this.getNameFromPayload(payload);
-    const organizations = this.getOrganizationsFromPayload(payload);
+    const organization = this.getOrganizationFromPayload(payload);
     const rolesFromSystem = this.getRoles(realmName);
     const roles = rolesFromPayload
       .reduce<Role[]>(
@@ -317,7 +317,7 @@ export class SecurityProvider {
       email,
       username,
       picture,
-      organizations,
+      organization,
       sessionId,
     };
   }
@@ -916,20 +916,15 @@ export class SecurityProvider {
     return this.UNKNOWN_USER_NAME;
   }
 
-  public getOrganizationsFromPayload(
+  public getOrganizationFromPayload(
     payload: Record<string, any>,
-  ): string[] | undefined {
+  ): string | undefined {
     if (!payload) {
       return;
     }
 
-    if (payload.organization) {
-      if (typeof payload.organization === "string") {
-        return [payload.organization];
-      }
-      if (Array.isArray(payload.organization)) {
-        return payload.organization;
-      }
+    if (typeof payload.organization === "string") {
+      return payload.organization;
     }
   }
 }

package/src/security/schemas/userAccountInfoSchema.ts

@@ -39,9 +39,9 @@ export const userAccountInfoSchema = t.object({
 
   // -------------------------------------------------------------------------------------------------------------------
 
-  organizations: t.optional(
-    t.array(t.text(), {
-      description: "List of organizations the user belongs to.",
+  organization: t.optional(
+    t.uuid({
+      description: "Organization the user belongs to.",
     }),
   ),
 

package/src/server/auth/providers/ServerAuthProvider.ts

@@ -50,6 +50,7 @@ export class ServerAuthProvider {
       realm: t.optional(t.text()),
       codeVerifier: t.optional(t.text({ size: "long" })),
       redirectUri: t.optional(t.text({ size: "long" })),
+      loginUri: t.optional(t.text({ size: "long" })),
       state: t.optional(t.text()),
       nonce: t.optional(t.text()),
     }),
@@ -278,7 +279,11 @@ export class ServerAuthProvider {
         redirect_uri: t.optional(t.text({ size: "rich" })),
       }),
     },
-    handler: async ({ query, url, reply }) => {
+    handler: async ({ query, url, reply, headers }) => {
+      const loginUri = headers.referer
+        ? new URL(headers.referer).pathname + new URL(headers.referer).search
+        : undefined;
+
       const provider = this.provider({
         provider: query.provider,
         realm: query.realm,
@@ -318,6 +323,7 @@ export class ServerAuthProvider {
           state,
           nonce: parameters.nonce,
           redirectUri: query.redirect_uri ?? "/",
+          loginUri,
           provider: query.provider,
           realm: query.realm,
         });
@@ -345,6 +351,7 @@ export class ServerAuthProvider {
       this.authorizationCode.set({
         codeVerifier,
         redirectUri: query.redirect_uri ?? "/",
+        loginUri,
         provider: query.provider,
         realm: query.realm,
       });
@@ -374,6 +381,7 @@ export class ServerAuthProvider {
       }
 
       const redirectUri = authorizationCode.redirectUri ?? "/";
+      const loginUri = authorizationCode.loginUri;
 
       const externalTokens = await authorizationCodeGrant(oauth, url, {
         pkceCodeVerifier: authorizationCode.codeVerifier,
@@ -405,7 +413,21 @@ export class ServerAuthProvider {
 
       // internal, we need to create our own tokens
 
-      const user = await provider.user(externalTokens);
+      let user: UserAccount;
+      try {
+        user = await provider.user(externalTokens);
+      } catch (e) {
+        this.log.warn("OAuth2 account linking failed", e);
+        const errorTarget = loginUri || redirectUri;
+        const errorUrl = new URL(errorTarget, url.origin);
+        errorUrl.searchParams.set(
+          "error",
+          e instanceof BadRequestError ? e.message : "Authentication failed",
+        );
+        reply.redirect(errorUrl.pathname + errorUrl.search, 302);
+        return;
+      }
+
       const tokens = await issuer.createToken(user);
 
       this.setTokens(

package/src/server/cookies/{services → __tests__}/CookieParser.spec.ts

@@ -1,6 +1,6 @@
 import { describe, it } from "vitest";
 import type { Cookie } from "../primitives/$cookie.ts";
-import { CookieParser } from "./CookieParser.ts";
+import { CookieParser } from "../services/CookieParser.ts";
 
 const parser = new CookieParser();
 

package/src/server/core/{primitives → __tests__}/$circuit.spec.ts

@@ -1,7 +1,7 @@
 import { $pipeline, Alepha } from "alepha";
 import { DateTimeProvider } from "alepha/datetime";
 import { describe, test } from "vitest";
-import { $circuit } from "./$circuit.ts";
+import { $circuit } from "../primitives/$circuit.ts";
 
 // -----------------------------------------------------------------------------------------------------------------
 // $circuit — core behavior

package/src/server/core/{providers → __tests__}/NodeHttpServerProvider.spec.ts

@@ -1,6 +1,6 @@
 import { Alepha } from "alepha";
 import { afterEach, describe, expect, test } from "vitest";
-import { NodeHttpServerProvider } from "./NodeHttpServerProvider.ts";
+import { NodeHttpServerProvider } from "../providers/NodeHttpServerProvider.ts";
 
 describe("NodeHttpServerProvider", () => {
   describe("graceful shutdown", () => {

package/src/server/core/{providers → __tests__}/ServerBodyParserProvider.spec.ts

@@ -5,7 +5,7 @@ import { $action, HttpError } from "../index.ts";
 import {
   bodyParserOptions,
   ServerBodyParserProvider,
-} from "./ServerBodyParserProvider.ts";
+} from "../providers/ServerBodyParserProvider.ts";
 
 describe("ServerBodyParserProvider", () => {
   it("should parse JSON body", async ({ expect }) => {
@@ -309,6 +309,36 @@ describe("ServerBodyParserProvider", () => {
     expect(result).toBeUndefined();
   });
 
+  it("should cancel stream reader when body exceeds limit", async ({
+    expect,
+  }) => {
+    const alepha = Alepha.create();
+    alepha.store.mut(bodyParserOptions, () => ({
+      inflate: true,
+      limit: 10,
+    }));
+    const parser = alepha.inject(ServerBodyParserProvider);
+    await alepha.start();
+
+    let readerCancelled = false;
+
+    // Stream must stay open (not closed) so cancel() is invocable
+    const stream = new ReadableStream({
+      pull(controller) {
+        controller.enqueue(new TextEncoder().encode("A".repeat(20)));
+      },
+      cancel() {
+        readerCancelled = true;
+      },
+    });
+
+    await expect(parser.parseText(stream)).rejects.toThrowError(
+      "Request body size limit exceeded",
+    );
+
+    expect(readerCancelled).toBe(true);
+  });
+
   it("should return undefined for unsupported content-type", async ({
     expect,
   }) => {

package/src/server/core/{providers → __tests__}/ServerCompressProvider.spec.ts

@@ -1,7 +1,7 @@
 import { Alepha } from "alepha";
 import { $action, $route, AlephaServer, ServerProvider } from "alepha/server";
 import { describe, it } from "vitest";
-import { compressOptions } from "./ServerCompressProvider.ts";
+import { compressOptions } from "../providers/ServerCompressProvider.ts";
 
 class App {
   hello = $action({

package/src/server/core/{providers → __tests__}/ServerHelmetProvider.spec.ts

@@ -1,7 +1,10 @@
 import { Alepha } from "alepha";
 import { $action, AlephaServer, ServerProvider } from "alepha/server";
 import { describe, expect, test } from "vitest";
-import { type HelmetOptions, helmetOptions } from "./ServerHelmetProvider.ts";
+import {
+  type HelmetOptions,
+  helmetOptions,
+} from "../providers/ServerHelmetProvider.ts";
 
 class TestApp {
   ping = $action({ handler: () => "pong" });

package/src/server/core/{providers → __tests__}/ServerMultipartProvider.spec.ts

@@ -1,7 +1,7 @@
 import { Alepha, t } from "alepha";
 import { $action, AlephaServer, ServerProvider } from "alepha/server";
 import { describe, test } from "vitest";
-import { multipartOptions } from "./ServerMultipartProvider.ts";
+import { multipartOptions } from "../providers/ServerMultipartProvider.ts";
 
 class App {
   upload = $action({

package/src/server/core/{services → __tests__}/ServerRequestParser.spec.ts

@@ -2,7 +2,7 @@ import { Alepha } from "alepha";
 import { describe, it } from "vitest";
 import { CryptoProvider } from "../../../crypto/index.ts";
 import type { ServerRequestData } from "../interfaces/ServerRequest.ts";
-import { ServerRequestParser } from "./ServerRequestParser.ts";
+import { ServerRequestParser } from "../services/ServerRequestParser.ts";
 
 const createMockRequestData = (
   headers: Record<string, string> = {},

package/src/server/core/primitives/$action.ts

@@ -1,7 +1,7 @@
 import {
   $atom,
   $inject,
-  $use,
+  $state,
   AlephaError,
   type Async,
   createPrimitive,
@@ -235,7 +235,7 @@ export class ActionPrimitive<
   TConfig extends RequestConfigSchema,
 > extends PipelinePrimitive<ActionPrimitiveOptions<TConfig>> {
   protected readonly log = $logger();
-  protected readonly settings = $use(serverApiOptions);
+  protected readonly settings = $state(serverApiOptions);
   protected readonly httpClient = $inject(HttpClient);
   protected readonly serverProvider = $inject(ServerProvider);
   protected readonly serverRouterProvider = $inject(ServerRouterProvider);

package/src/server/core/primitives/$sse.ts

@@ -1,6 +1,6 @@
 import {
   $inject,
-  $use,
+  $state,
   AlephaError,
   type Async,
   createPrimitive,
@@ -392,7 +392,7 @@ export class SsePrimitive<
   TConfig extends SseConfigSchema,
 > extends PipelinePrimitive<SsePrimitiveOptions<TConfig>> {
   protected readonly log = $logger();
-  protected readonly settings = $use(serverApiOptions);
+  protected readonly settings = $state(serverApiOptions);
   protected readonly serverProvider = $inject(ServerProvider);
   protected readonly serverRouterProvider = $inject(ServerRouterProvider);
 

package/src/server/core/providers/ServerBodyParserProvider.ts

@@ -1,7 +1,7 @@
 import { Readable } from "node:stream";
 import { createBrotliDecompress, createGunzip, createInflate } from "node:zlib";
 import type { TSchema } from "alepha";
-import { $atom, $hook, $inject, $use, Alepha, type Static, t } from "alepha";
+import { $atom, $hook, $inject, $state, Alepha, type Static, t } from "alepha";
 import { $logger } from "alepha/logger";
 import { HttpError } from "../errors/HttpError.ts";
 
@@ -42,7 +42,7 @@ declare module "alepha" {
 export class ServerBodyParserProvider {
   protected readonly alepha = $inject(Alepha);
   protected readonly log = $logger();
-  protected readonly options = $use(bodyParserOptions);
+  protected readonly options = $state(bodyParserOptions);
 
   public readonly onRequest = $hook({
     on: "server:onRequest",
@@ -99,14 +99,20 @@ export class ServerBodyParserProvider {
       }
 
       if (route.schema?.body) {
-        const contentLength = request.headers["content-length"];
-        if (contentLength) {
-          const size = Number.parseInt(contentLength, 10);
-          if (!Number.isNaN(size) && size > this.options.limit) {
-            throw new HttpError({
-              status: 413,
-              message: "Request body size limit exceeded",
-            });
+        const contentType = request.headers["content-type"] ?? "";
+
+        // Skip body size check for multipart requests — ServerMultipartProvider
+        // handles its own limits (multipartOptions.limit / fileLimit).
+        if (!contentType.startsWith("multipart/")) {
+          const contentLength = request.headers["content-length"];
+          if (contentLength) {
+            const size = Number.parseInt(contentLength, 10);
+            if (!Number.isNaN(size) && size > this.options.limit) {
+              throw new HttpError({
+                status: 413,
+                message: "Request body size limit exceeded",
+              });
+            }
           }
         }
 
@@ -260,12 +266,14 @@ export class ServerBodyParserProvider {
     let totalLength = 0;
 
     const reader = stream.getReader();
+    let needsCancel = true;
 
     try {
       while (true) {
         const { done, value } = await reader.read();
 
         if (done) {
+          needsCancel = false;
           break;
         }
 
@@ -277,8 +285,6 @@ export class ServerBodyParserProvider {
               `Body size limit exceeded: ${totalLength} > ${limit}`,
             );
 
-            await reader.cancel();
-
             throw new HttpError({
               status: 413,
               message: "Request body size limit exceeded",
@@ -303,6 +309,9 @@ export class ServerBodyParserProvider {
         combined.byteLength,
       );
     } finally {
+      if (needsCancel) {
+        await reader.cancel().catch(() => {});
+      }
       reader.releaseLock();
     }
   }

package/src/server/core/providers/ServerCompressProvider.ts

@@ -2,7 +2,7 @@ import { Readable, type Transform } from "node:stream";
 import { ReadableStream } from "node:stream/web";
 import { promisify } from "node:util";
 import * as zlib from "node:zlib";
-import { $atom, $hook, $inject, $use, Alepha, type Static, t } from "alepha";
+import { $atom, $hook, $inject, $state, Alepha, type Static, t } from "alepha";
 import type { ServerResponse } from "alepha/server";
 
 const gzip = promisify(zlib.gzip);
@@ -77,7 +77,7 @@ export class ServerCompressProvider {
   };
 
   protected readonly alepha = $inject(Alepha);
-  protected readonly options = $use(compressOptions);
+  protected readonly options = $state(compressOptions);
 
   public readonly onResponse = $hook({
     on: "server:onResponse",

package/src/server/core/providers/ServerHelmetProvider.ts

@@ -1,4 +1,4 @@
-import { $atom, $hook, $inject, $use, Alepha, type Static, t } from "alepha";
+import { $atom, $hook, $inject, $state, Alepha, type Static, t } from "alepha";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
@@ -102,7 +102,7 @@ export class ServerHelmetProvider {
   /**
    * The configuration options loaded from the atom.
    */
-  protected readonly options = $use(helmetOptions);
+  protected readonly options = $state(helmetOptions);
 
   protected defaultCspDirectives(): CspDirectives {
     return {

package/src/server/core/providers/ServerMultipartProvider.ts

@@ -3,7 +3,7 @@ import {
   $atom,
   $hook,
   $inject,
-  $use,
+  $state,
   Alepha,
   type FileLike,
   isTypeFile,
@@ -57,7 +57,7 @@ declare module "alepha" {
 export class ServerMultipartProvider {
   protected readonly alepha = $inject(Alepha);
   protected readonly log = $logger();
-  protected readonly options = $use(multipartOptions);
+  protected readonly options = $state(multipartOptions);
 
   public readonly onRequest = $hook({
     on: "server:onRequest",

package/src/server/core/providers/ServerRouterProvider.ts

@@ -310,11 +310,7 @@ export class ServerRouterProvider extends RouterProvider<ServerRouteMatcher> {
     if (responseKind === "text") {
       reply.body = String(reply.body);
       // Detect HTML responses (starts with <!DOCTYPE html>)
-      if (
-        reply.body.length > 15 &&
-        reply.body.charCodeAt(0) === 60 &&
-        reply.body.startsWith("<!DOCTYPE html>")
-      ) {
+      if (reply.body.startsWith("<!DOCTYPE html>")) {
         headers["content-type"] ??= "text/html; charset=UTF-8";
       } else {
         headers["content-type"] ??= "text/plain";

package/src/server/cors/{primitives → __tests__}/$cors.spec.ts

@@ -2,7 +2,7 @@ import { $pipeline, Alepha } from "alepha";
 import { AlephaServer } from "alepha/server";
 import { describe, test } from "vitest";
 import { AlephaServerCors } from "../index.ts";
-import { $cors } from "./$cors.ts";
+import { $cors } from "../primitives/$cors.ts";
 
 // -----------------------------------------------------------------------------------------------------------------
 // $cors — core behavior

package/src/server/cors/providers/ServerCorsProvider.ts

@@ -1,4 +1,4 @@
-import { $atom, $hook, $inject, $use, type Static, t } from "alepha";
+import { $atom, $hook, $inject, $state, type Static, t } from "alepha";
 import { $logger } from "alepha/logger";
 import { ServerRouterProvider } from "alepha/server";
 
@@ -69,7 +69,7 @@ export interface CorsRegistration extends Partial<CorsOptions> {
 export class ServerCorsProvider {
   protected readonly log = $logger();
   protected readonly serverRouterProvider = $inject(ServerRouterProvider);
-  protected readonly globalOptions = $use(corsOptions);
+  protected readonly globalOptions = $state(corsOptions);
 
   /**
    * Registered CORS configurations with their path patterns

package/src/server/links/{services → __tests__}/BatchCollector.spec.ts

@@ -1,6 +1,6 @@
 import { Alepha } from "alepha";
 import { describe, it } from "vitest";
-import { BatchCollector } from "./BatchCollector.ts";
+import { BatchCollector } from "../services/BatchCollector.ts";
 
 describe("BatchCollector", () => {
   it("should deduplicate identical entries", ({ expect }) => {

package/src/server/links/providers/LinkProvider.ts

@@ -1,4 +1,4 @@
-import { $inject, $use, Alepha, AlephaError, type Async, t } from "alepha";
+import { $inject, $state, Alepha, AlephaError, type Async, t } from "alepha";
 import { $logger } from "alepha/logger";
 import type { SecureOptions } from "alepha/security";
 import {
@@ -50,7 +50,7 @@ export class LinkProvider {
   // Browser-only: batch collector for coalescing multiple calls
   protected batchCollector?: BatchCollector;
 
-  protected readonly options = $use(linkOptionsAtom);
+  protected readonly options = $state(linkOptionsAtom);
 
   /**
    * Get applicative links registered on the server.