@livestore/utils 0.4.0-dev.9 → 0.5.0-dev.0

package/src/effect/Effect.test.ts

@@ -0,0 +1,117 @@
+import { describe, expect, expectTypeOf, it } from '@effect/vitest'
+import { Cause, Effect } from 'effect'
+
+import { trySyncOrPromiseOrEffect } from './Effect.ts'
+
+interface RequiredService {
+  readonly RequiredService: unique symbol
+}
+
+declare const contextualEffect: Effect.Effect<number, 'effect-error', RequiredService>
+
+describe('trySyncOrPromiseOrEffect', () => {
+  it.effect('returns a plain value', () =>
+    Effect.gen(function* () {
+      const result = yield* trySyncOrPromiseOrEffect(() => 42 as const)
+
+      expect(result).toBe(42)
+    }),
+  )
+
+  it.effect('evaluates the operation lazily for each execution', () =>
+    Effect.gen(function* () {
+      let executions = 0
+      const effect = trySyncOrPromiseOrEffect(() => ++executions)
+
+      expect(executions).toBe(0)
+      expect(yield* effect).toBe(1)
+      expect(yield* effect).toBe(2)
+    }),
+  )
+
+  it.effect('maps a synchronous throw to an UnknownError', () =>
+    Effect.gen(function* () {
+      const thrown = new Error('thrown')
+      const failure = yield* trySyncOrPromiseOrEffect(() => {
+        throw thrown
+      }).pipe(Effect.flip)
+
+      expect(failure).toBeInstanceOf(Cause.UnknownError)
+      if (failure instanceof Cause.UnknownError) {
+        expect(failure.cause).toBe(thrown)
+      }
+    }),
+  )
+
+  it.effect('awaits a resolving Promise', () =>
+    Effect.gen(function* () {
+      const result = yield* trySyncOrPromiseOrEffect(() => Promise.resolve('resolved'))
+
+      expect(result).toBe('resolved')
+    }),
+  )
+
+  it.effect('maps a rejected Promise to an UnknownError', () =>
+    Effect.gen(function* () {
+      const rejected = new Error('rejected')
+      const failure = yield* trySyncOrPromiseOrEffect(() => Promise.reject(rejected)).pipe(Effect.flip)
+
+      expect(failure).toBeInstanceOf(Cause.UnknownError)
+      if (failure instanceof Cause.UnknownError) {
+        expect(failure.cause).toBe(rejected)
+      }
+    }),
+  )
+
+  it.effect('maps a throwing Promise-like then getter to an UnknownError', () =>
+    Effect.gen(function* () {
+      const thrown = new Error('throwing then getter')
+      const thenable = {
+        // oxlint-disable-next-line eslint-plugin-unicorn(no-thenable) -- intentionally exercises Promise-like classification
+        get then(): PromiseLike<never>['then'] {
+          throw thrown
+        },
+      } satisfies PromiseLike<never>
+
+      const failure = yield* trySyncOrPromiseOrEffect(() => thenable).pipe(Effect.flip)
+
+      expect(failure).toBeInstanceOf(Cause.UnknownError)
+      if (failure instanceof Cause.UnknownError) {
+        expect(failure.cause).toBe(thrown)
+      }
+    }),
+  )
+
+  it.effect('executes and returns the value of a returned Effect', () =>
+    Effect.gen(function* () {
+      const result = yield* trySyncOrPromiseOrEffect(() => Effect.succeed('effect-value'))
+
+      expect(result).toBe('effect-value')
+    }),
+  )
+
+  it.effect('preserves a returned Effect failure', () =>
+    Effect.gen(function* () {
+      const expected = { _tag: 'ExpectedError' as const }
+      const failure = yield* trySyncOrPromiseOrEffect(() => Effect.fail(expected)).pipe(Effect.flip)
+
+      expect(failure).toBe(expected)
+    }),
+  )
+
+  it('preserves returned Effect success, error, and requirements types', () => {
+    const normalized = trySyncOrPromiseOrEffect(() => contextualEffect)
+
+    expectTypeOf(normalized).toEqualTypeOf<
+      Effect.Effect<number, 'effect-error' | Cause.UnknownError, RequiredService>
+    >()
+  })
+
+  it('returns an Effect when the operation only throws', () => {
+    const normalized = trySyncOrPromiseOrEffect((): never => {
+      throw new Error('thrown')
+    })
+
+    expectTypeOf(normalized).toEqualTypeOf<Effect.Effect<never, Cause.UnknownError>>()
+  })
+})

package/src/effect/Effect.ts

@@ -1,27 +1,23 @@
-import * as OtelTracer from '@effect/opentelemetry/Tracer'
+import * as OtelTracer from '@effect/opentelemetry/OtelTracer'
 import {
   Cause,
+  Console,
   type Context,
   Deferred,
   Duration,
   Effect,
+  Function,
   Fiber,
-  FiberRef,
-  HashSet,
-  Logger,
   pipe,
+  Predicate,
   Scope,
   type Stream,
 } from 'effect'
-import type { UnknownException } from 'effect/Cause'
-import { log } from 'effect/Console'
-import { dual, type LazyArg } from 'effect/Function'
-import type { Predicate, Refinement } from 'effect/Predicate'
 
-import { isPromise } from '../mod.ts'
-import { UnknownError } from './Error.ts'
+import { isDevEnv, objectToString } from '../misc.ts'
 
 export * from 'effect/Effect'
+export { spanEvent } from './spanEvent.ts'
 
 // export const log = <A>(message: A, ...rest: any[]): Effect.Effect<void> =>
 //   Effect.sync(() => {
@@ -38,16 +34,14 @@ export * from 'effect/Effect'
 //     console.error(message, ...rest)
 //   })
 
-/** Same as `Effect.scopeWith` but with a `CloseableScope` instead of a `Scope`. */
+/** Same as `Effect.scopeWith` but with a closeable `Scope`. */
 export const scopeWithCloseable = <R, E, A>(
-  fn: (scope: Scope.CloseableScope) => Effect.Effect<A, E, R | Scope.Scope>,
+  fn: (scope: Scope.Closeable) => Effect.Effect<A, E, R | Scope.Scope>,
 ): Effect.Effect<A, E, R | Scope.Scope> =>
   Effect.gen(function* () {
-    // const parentScope = yield* Scope.Scope
-    // const scope = yield* Scope.fork(parentScope, ExecutionStrategy.sequential)
     const scope = yield* Scope.make()
     yield* Effect.addFinalizer((exit) => Scope.close(scope, exit))
-    return yield* fn(scope).pipe(Scope.extend(scope))
+    return yield* fn(scope).pipe(Scope.provide(scope))
   })
 
 export type SyncOrPromiseOrEffect<TResult, TError = never, TContext = never> =
@@ -55,22 +49,43 @@ export type SyncOrPromiseOrEffect<TResult, TError = never, TContext = never> =
   | Promise<TResult>
   | Effect.Effect<TResult, TError, TContext>
 
-export const tryAll = <Res>(
-  fn: () => Res,
-): Res extends Effect.Effect<infer A, infer E, never>
-  ? Effect.Effect<A, E | UnknownException, never>
-  : Res extends Promise<infer A>
-    ? Effect.Effect<A, UnknownException, never>
-    : Effect.Effect<Res, UnknownException, never> =>
-  Effect.try(() => fn()).pipe(
-    Effect.andThen((fnRes) =>
-      Effect.isEffect(fnRes)
-        ? (fnRes as any as Effect.Effect<any>)
-        : isPromise(fnRes)
-          ? Effect.promise(() => fnRes)
-          : Effect.succeed(fnRes),
-    ),
-  ) as any
+/**
+ * Creates an Effect from an operation that may return a value, a Promise-like value, or another Effect.
+ *
+ * @remarks
+ * Synchronous values succeed directly, and Promise-like values are awaited. Synchronous throws and Promise rejections
+ * are mapped to `Cause.UnknownError`. When the operation returns an Effect, that Effect is executed rather than
+ * produced as a successful value; its failures and service requirements are preserved.
+ *
+ * @param operation - A callback that may return a synchronous value, a Promise-like value, or an Effect
+ * @returns An Effect representing the normalized outcome of the operation
+ */
+export function trySyncOrPromiseOrEffect<Return>(
+  operation: () => Return,
+): Effect.Effect<
+  Return extends Effect.Effect<infer A, infer _E, infer _R> ? A : Return extends PromiseLike<infer A> ? A : Return,
+  Cause.UnknownError | (Return extends Effect.Effect<infer _A, infer E, infer _R> ? E : never),
+  Return extends Effect.Effect<infer _A, infer _E, infer R> ? R : never
+>
+export function trySyncOrPromiseOrEffect(operation: () => unknown): Effect.Effect<unknown, unknown, unknown> {
+  return Effect.try({
+    try: () => {
+      const result = operation()
+
+      if (Effect.isEffect(result) === true) {
+        // @effect-diagnostics-next-line anyUnknownInErrorContext:off -- dynamic implementation boundary; the public overload preserves exact Effect error and requirement channels
+        return result
+      }
+
+      if (Predicate.isPromiseLike(result) === true) {
+        return Effect.tryPromise(() => result)
+      }
+
+      return Effect.succeed(result)
+    },
+    catch: (cause) => new Cause.UnknownError(cause),
+  }).pipe(Effect.flatten)
+}
 
 export const acquireReleaseLog = (label: string) =>
   Effect.acquireRelease(Effect.log(`${label} acquire`), (_, ex) => Effect.log(`${label} release`, ex))
@@ -87,16 +102,11 @@ export const logBefore =
 
 /** Logs both on errors and defects */
 export const tapCauseLogPretty = <R, E, A>(eff: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
-  Effect.tapErrorCause(eff, (cause) =>
+  Effect.tapCause(eff, (cause) =>
     Effect.gen(function* () {
-      if (Cause.isInterruptedOnly(cause)) {
-        // console.log('interrupted', Cause.pretty(err), err)
-        return
-      }
+      if (Cause.hasInterruptsOnly(cause) === true) return
 
-      const span = yield* OtelTracer.currentOtelSpan.pipe(
-        Effect.catchTag('NoSuchElementException', (_) => Effect.succeed(undefined)),
-      )
+      const span = yield* OtelTracer.currentOtelSpan.pipe(Effect.catchTag('NoSuchElementError', (_) => Effect.void))
 
       const firstErrLine = cause.toString().split('\n')[0]
       yield* Effect.logError(firstErrLine, cause).pipe((_) =>
@@ -107,46 +117,82 @@ export const tapCauseLogPretty = <R, E, A>(eff: Effect.Effect<A, E, R>): Effect.
     }),
   )
 
+/**
+ * Creates a defect, pausing at a breakpoint in development.
+ *
+ * @param msg - The error message to include in the defect.
+ * @param args - Arbitrary arguments available for inspection during debugging.
+ *
+ * @see {@link shouldNeverHappen} for the non-Effect equivalent that throws synchronously.
+ * @see {@link orDieDebugger}
+ */
+export const dieDebugger = (msg: string, ...args: ReadonlyArray<unknown>): Effect.Effect<never> =>
+  Effect.suspend(() => {
+    if (isDevEnv() === true) {
+      // oxlint-disable-next-line eslint(no-debugger) -- intentional breakpoint during development
+      debugger
+      void args // Keeps the variable in scope so it's inspectable when the debugger pauses
+    }
+    return Effect.die(new Error(msg))
+  })
+
+/**
+ * Converts a failure into a defect, pausing at a breakpoint in development.
+ *
+ * @param self - The effect on which to apply the operation.
+ *
+ * @see {@link Effect.orDie}
+ * @see {@link dieDebugger}
+ */
+export const orDieDebugger = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, never, R> =>
+  Effect.matchEffect(self, {
+    onFailure: (error) =>
+      // Keep the debugger hook so that `debugger` runs only when the wrapped effect actually fails, not while building the wrapper.
+      Effect.suspend(() => {
+        if (isDevEnv() === true) {
+          // oxlint-disable-next-line eslint(no-debugger) -- intentional breakpoint for impossible states during development
+          debugger
+        }
+        return Effect.die(error)
+      }),
+    onSuccess: Effect.succeed,
+  })
+
 export const ignoreIf: {
   <E, EB extends E>(
-    refinement: Refinement<NoInfer<E>, EB>,
+    refinement: Predicate.Refinement<NoInfer<E>, EB>,
   ): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<void, Exclude<E, EB>, R>
-  <E>(predicate: Predicate<NoInfer<E>>): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<void, E, R>
+  <E>(predicate: Predicate.Predicate<NoInfer<E>>): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<void, E, R>
   <A, E, R, EB extends E>(
     self: Effect.Effect<A, E, R>,
-    refinement: Refinement<E, EB>,
+    refinement: Predicate.Refinement<E, EB>,
   ): Effect.Effect<void, Exclude<E, EB>, R>
-  <A, E, R>(self: Effect.Effect<A, E, R>, predicate: Predicate<E>): Effect.Effect<void, E, R>
-} = dual(2, <A, E, R>(self: Effect.Effect<A, E, R>, predicate: Predicate<E>) =>
+  <A, E, R>(self: Effect.Effect<A, E, R>, predicate: Predicate.Predicate<E>): Effect.Effect<void, E, R>
+} = Function.dual(2, <A, E, R>(self: Effect.Effect<A, E, R>, predicate: Predicate.Predicate<E>) =>
   self.pipe(Effect.catchIf(predicate, () => Effect.void)),
 )
 
 export const eventListener = <TEvent = unknown>(
   target: Stream.EventListener<TEvent>,
   type: string,
-  handler: (event: TEvent) => Effect.Effect<void, never, never>,
+  handler: (event: TEvent) => Effect.Effect<void>,
   options?: { once?: boolean },
 ) =>
   Effect.gen(function* () {
-    const runtime = yield* Effect.runtime<never>()
+    const services = yield* Effect.context()
 
-    const handlerFn = (event: TEvent) => handler(event).pipe(Effect.provide(runtime), Effect.runFork)
+    const handlerFn = (event: TEvent) => handler(event).pipe(Effect.runForkWith(services))
 
     target.addEventListener(type, handlerFn, { once: options?.once ?? false })
 
     yield* Effect.addFinalizer(() => Effect.sync(() => target.removeEventListener(type, handlerFn)))
   })
 
-export const spanEvent = (message: any, attributes?: Record<string, any>) =>
-  Effect.locallyWith(Effect.log(message).pipe(Effect.annotateLogs(attributes ?? {})), FiberRef.currentLoggers, () =>
-    HashSet.make(Logger.tracerLogger),
-  )
-
 export const logWarnIfTakesLongerThan =
-  ({ label, duration }: { label: string; duration: Duration.DurationInput }) =>
+  ({ label, duration }: { label: string; duration: Duration.Input }) =>
   <R, E, A>(eff: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
     Effect.gen(function* () {
-      const runtime = yield* Effect.runtime<never>()
+      const services = yield* Effect.context()
 
       let tookLongerThanTimer = false
 
@@ -154,10 +200,9 @@ export const logWarnIfTakesLongerThan =
         Effect.tap(() => {
           tookLongerThanTimer = true
           // TODO include span info
-          return Effect.logWarning(`${label}: Took longer than ${duration}ms`)
+          return Effect.logWarning(`${label}: Took longer than ${objectToString(duration)}ms`)
         }),
-        Effect.provide(runtime),
-        Effect.runFork,
+        Effect.runForkWith(services),
       )
 
       const start = Date.now()
@@ -169,13 +214,14 @@ export const logWarnIfTakesLongerThan =
 
             yield* Fiber.interrupt(timeoutFiber)
 
-            if (tookLongerThanTimer) {
+            if (tookLongerThanTimer === true) {
               yield* Effect.logWarning(`${label}: Interrupted after ${end - start}ms`)
             }
           }),
         ),
       )
 
+      // eslint-disable-next-line overeng/explicit-boolean-compare -- mutated in forked fiber; TS can't see the mutation
       if (tookLongerThanTimer) {
         const end = Date.now()
         yield* Effect.logWarning(`${label}: Actual duration: ${end - start}ms`)
@@ -193,7 +239,7 @@ export const logDuration =
       const start = Date.now()
       const res = yield* eff
       const end = Date.now()
-      yield* Effect.log(`${label}: ${Duration.format(end - start)}`)
+      yield* Effect.log(`${label}: ${Duration.format(Duration.millis(end - start))}`)
       return res
     })
 
@@ -205,22 +251,66 @@ export const tapSync =
 export const debugLogEnv = (msg?: string): Effect.Effect<Context.Context<never>> =>
   pipe(
     Effect.context<never>(),
-    Effect.tap((env) => log(msg ?? 'debugLogEnv', env)),
+    Effect.tap((env) => Console.log(msg ?? 'debugLogEnv', env)),
   )
 
-export const timeoutDie =
-  <E1>(options: { onTimeout: LazyArg<E1>; duration: Duration.DurationInput }) =>
-  <R, E, A>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
-    Effect.orDie(Effect.timeoutFail(options)(self))
-
-export const timeoutDieMsg =
-  (options: { error: string; duration: Duration.DurationInput }) =>
-  <R, E, A>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
-    Effect.orDie(
-      Effect.timeoutFail({ onTimeout: () => new UnknownError({ cause: options.error }), duration: options.duration })(
-        self,
-      ),
-    )
+/**
+ * Enforces a time limit on an effect, triggering a defect on timeout.
+ *
+ * @remarks
+ *
+ * This function allows you to enforce a time limit on the execution of an
+ * effect. If the effect does not complete within the given duration, it dies
+ * with a {@link Cause.TimeoutError} as an unchecked defect. Unlike
+ * {@link Effect.timeout}, which adds `TimeoutError` to the error channel,
+ * this function keeps the error channel unchanged by treating the timeout as
+ * a defect.
+ *
+ * The returned effect will either:
+ * - Succeed with the original effect's result if it completes within the
+ *   specified duration.
+ * - Die with a {@link Cause.TimeoutError} defect if the time limit is exceeded.
+ *
+ * @see {@link timeoutOrDieMessage} for a version with a custom message.
+ * @see {@link Effect.timeout} for a version that raises a `TimeoutError` as a typed error.
+ * @see {@link Effect.timeoutOrElse} for a version with a custom timeout branch.
+ */
+export const timeoutOrDie =
+  (duration: Duration.Input) =>
+  <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+    Effect.timeoutOrElse(self, {
+      duration,
+      orElse: () => Effect.die(new Cause.TimeoutError()),
+    })
+
+/**
+ * Enforces a time limit on an effect, triggering a defect with a custom
+ * message on timeout.
+ *
+ * @remarks
+ *
+ * This function behaves like {@link timeoutOrDie}, but allows you to provide
+ * a custom message for the {@link Cause.TimeoutError} defect. This is useful
+ * for adding context about which operation timed out, making it easier to
+ * diagnose issues in logs or error reports.
+ *
+ * The returned effect will either:
+ * - Succeed with the original effect's result if it completes within the
+ *   specified duration.
+ * - Die with a {@link Cause.TimeoutError} defect containing the provided
+ *   message if the time limit is exceeded.
+ *
+ * @see {@link timeoutOrDie} for a version without a custom message.
+ * @see {@link Effect.timeout} for a version that raises a `TimeoutError` as a typed error.
+ * @see {@link Effect.timeoutOrElse} for a version with a custom timeout branch.
+ */
+export const timeoutOrDieMessage =
+  (duration: Duration.Input, message: string) =>
+  <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+    Effect.timeoutOrElse(self, {
+      duration,
+      orElse: () => Effect.die(new Cause.TimeoutError(message)),
+    })
 
 export const toForkedDeferred = <R, E, A>(
   eff: Effect.Effect<A, E, R>,
@@ -251,16 +341,16 @@ export const withPerformanceMeasure =
     )
 
 const getSpanTrace = () => {
-  const fiberOption = Fiber.getCurrentFiber()
-  if (fiberOption._tag === 'None' || fiberOption.value.currentSpan === undefined) {
+  const fiber = Fiber.getCurrent()
+  if (fiber === undefined || fiber.currentSpan === undefined) {
     return 'No current fiber'
   }
 
   return ''
   // const msg = Effect.runSync(
   //   Effect.fail({ message: '' }).pipe(
-  //     Effect.withParentSpan(fiberOption.value.currentSpan),
-  //     Effect.catchAllCause((cause) => Effect.succeed(cause.toString())),
+  //     Effect.withParentSpan(fiber.currentSpan),
+  //     Effect.catchCause((cause) => Effect.succeed(cause.toString())),
   //   ),
   // )
 
@@ -274,7 +364,12 @@ const getSpanTrace = () => {
 
 const logSpanTrace = () => console.log(getSpanTrace())
 
-// @ts-expect-error TODO fix types
+declare global {
+  /** Debug helper: returns the current Effect span trace */
+  var getSpanTrace: () => string
+  /** Debug helper: logs the current Effect span trace */
+  var logSpanTrace: () => void
+}
+
 globalThis.getSpanTrace = getSpanTrace
-// @ts-expect-error TODO fix types
 globalThis.logSpanTrace = logSpanTrace

package/src/effect/Error.ts

@@ -1,6 +1,6 @@
 import { Schema } from 'effect'
 
-export class UnknownError extends Schema.TaggedError<UnknownError>()('UnknownError', {
+export class UnknownError extends Schema.TaggedError<UnknownError>('~@livestore/utils/UnknownError')('UnknownError', {
   cause: Schema.Any,
   payload: Schema.optional(Schema.Any),
 }) {}

package/src/effect/Logger.ts

@@ -1,49 +1 @@
-import { Cause, HashMap, Logger, LogLevel } from 'effect'
-
 export * from 'effect/Logger'
-
-const defaultDateFormat = (date: Date): string =>
-  `${date.getHours().toString().padStart(2, '0')}:${date.getMinutes().toString().padStart(2, '0')}:${date
-    .getSeconds()
-    .toString()
-    .padStart(2, '0')}.${date.getMilliseconds().toString().padStart(3, '0')}`
-
-export const prettyWithThread = (threadName: string, options: { mode?: 'tty' | 'browser' } = {}) =>
-  Logger.replace(
-    Logger.defaultLogger,
-    Logger.prettyLogger({
-      formatDate: (date) => `${defaultDateFormat(date)} ${threadName}`,
-      mode: options.mode,
-    }),
-  )
-
-export const consoleLogger = (threadName: string) =>
-  Logger.make(({ message, annotations, date, logLevel, cause }) => {
-    const isCloudflareWorker = typeof navigator !== 'undefined' && navigator.userAgent === 'Cloudflare-Workers'
-    const consoleFn =
-      logLevel === LogLevel.Debug
-        ? // Cloudflare Workers doesn't support console.debug 🤷
-          isCloudflareWorker
-          ? console.log
-          : console.debug
-        : logLevel === LogLevel.Info
-          ? console.info
-          : logLevel === LogLevel.Warning
-            ? console.warn
-            : console.error
-
-    const annotationsObj = Object.fromEntries(HashMap.entries(annotations))
-
-    const messages = Array.isArray(message) ? message : [message]
-    if (Cause.isEmpty(cause) === false) {
-      messages.push(Cause.pretty(cause, { renderErrorCause: true }))
-    }
-
-    if (Object.keys(annotationsObj).length > 0) {
-      messages.push(annotationsObj)
-    }
-
-    consoleFn(`[${defaultDateFormat(date)} ${threadName}]`, ...messages)
-  })
-
-export const consoleWithThread = (threadName: string) => Logger.replace(Logger.defaultLogger, consoleLogger(threadName))

package/src/effect/OtelTracer.ts

@@ -1,11 +1,10 @@
-import { makeExternalSpan } from '@effect/opentelemetry/Tracer'
+import { makeExternalSpan } from '@effect/opentelemetry/OtelTracer'
 import type { Link as OtelSpanLink } from '@opentelemetry/api'
 import type { SpanLink as EffectSpanLink } from 'effect/Tracer'
 
-export * from '@effect/opentelemetry/Tracer'
+export * from '@effect/opentelemetry/OtelTracer'
 
 export const makeSpanLink = (otelSpanLink: OtelSpanLink): EffectSpanLink => ({
-  _tag: 'SpanLink',
   span: makeExternalSpan(otelSpanLink.context),
   attributes: otelSpanLink.attributes ?? {},
 })