effect 4.0.0-beta.94 → 4.0.0-beta.98

package/src/unstable/reactivity/AtomHttpApi.ts

@@ -40,7 +40,7 @@ import * as Reactivity from "./Reactivity.ts"
  * @category models
  * @since 4.0.0
  */
-export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpApiGroup.Any>
+export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpApiGroup.Constraint>
   extends Context.Service<Self, HttpApiClient.Client<Groups, never, never>>
 {
   new(_: never): Context.ServiceClass.Shape<Id, HttpApiClient.Client<Groups, never, never>>
@@ -48,23 +48,23 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
   readonly runtime: Atom.AtomRuntime<Self>
 
   readonly mutation: <
-    GroupName extends HttpApiGroup.Name<Groups>,
-    Name extends HttpApiEndpoint.Name<HttpApiGroup.Endpoints<Group>>,
-    Group extends HttpApiGroup.Any = HttpApiGroup.WithName<Groups, GroupName>,
-    Endpoint extends HttpApiEndpoint.Any = HttpApiEndpoint.WithName<
+    GroupIdentifier extends HttpApiGroup.Identifier<Groups>,
+    EndpointIdentifier extends HttpApiEndpoint.Identifier<HttpApiGroup.Endpoints<Group>>,
+    Group extends HttpApiGroup.Constraint = HttpApiGroup.WithIdentifier<Groups, GroupIdentifier>,
+    Endpoint extends HttpApiEndpoint.Constraint = HttpApiEndpoint.WithIdentifier<
       HttpApiGroup.Endpoints<Group>,
-      Name
+      EndpointIdentifier
     >,
     const ResponseMode extends HttpApiEndpoint.ClientResponseMode = HttpApiEndpoint.ClientResponseMode
   >(
-    group: GroupName,
-    endpoint: Name,
+    group: GroupIdentifier,
+    endpoint: EndpointIdentifier,
     options?: {
       readonly responseMode?: ResponseMode | undefined
     }
   ) => [Endpoint] extends [
     HttpApiEndpoint.HttpApiEndpoint<
-      infer _Name,
+      infer _Identifier,
       infer _Method,
       infer _Path,
       infer _Params,
@@ -88,20 +88,20 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
     : never
 
   readonly query: <
-    GroupName extends HttpApiGroup.Name<Groups>,
-    Name extends HttpApiEndpoint.Name<HttpApiGroup.Endpoints<Group>>,
-    Group extends HttpApiGroup.Any = HttpApiGroup.WithName<Groups, GroupName>,
-    Endpoint extends HttpApiEndpoint.Any = HttpApiEndpoint.WithName<
+    GroupIdentifier extends HttpApiGroup.Identifier<Groups>,
+    EndpointIdentifier extends HttpApiEndpoint.Identifier<HttpApiGroup.Endpoints<Group>>,
+    Group extends HttpApiGroup.Constraint = HttpApiGroup.WithIdentifier<Groups, GroupIdentifier>,
+    Endpoint extends HttpApiEndpoint.Constraint = HttpApiEndpoint.WithIdentifier<
       HttpApiGroup.Endpoints<Group>,
-      Name
+      EndpointIdentifier
     >,
     const ResponseMode extends HttpApiEndpoint.ClientResponseMode = "decoded-only"
   >(
-    group: GroupName,
-    endpoint: Name,
+    group: GroupIdentifier,
+    endpoint: EndpointIdentifier,
     request: [Endpoint] extends [
       HttpApiEndpoint.HttpApiEndpoint<
-        infer _Name,
+        infer _Identifier,
         infer _Method,
         infer _Path,
         infer _Params,
@@ -126,7 +126,7 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
       : never
   ) => [Endpoint] extends [
     HttpApiEndpoint.HttpApiEndpoint<
-      infer _Name,
+      infer _Identifier,
       infer _Method,
       infer _Path,
       infer _Params,
@@ -166,157 +166,159 @@ declare global {
  * @category constructors
  * @since 4.0.0
  */
-export const Service = <Self>() =>
-<const Id extends string, ApiId extends string, Groups extends HttpApiGroup.Any>(
-  id: Id,
-  options: {
-    readonly api: HttpApi.HttpApi<ApiId, Groups>
-    readonly httpClient:
-      | Layer.Layer<
-        | HttpApiGroup.ClientServices<Groups>
-        | HttpClient.HttpClient
-      >
-      | ((get: Atom.AtomContext) => Layer.Layer<
-        | HttpApiGroup.ClientServices<Groups>
-        | HttpClient.HttpClient
-      >)
-    readonly transformClient?: ((client: HttpClient.HttpClient) => HttpClient.HttpClient) | undefined
-    readonly transformResponse?:
-      | ((effect: Effect.Effect<unknown, unknown, unknown>) => Effect.Effect<unknown, unknown, unknown>)
-      | undefined
-    readonly baseUrl?: URL | string | undefined
-    readonly runtime?: Atom.RuntimeFactory | undefined
-  }
-): AtomHttpApiClient<Self, Id, Groups> => {
-  const self: Mutable<AtomHttpApiClient<Self, Id, Groups>> = Context.Service<
-    Self,
-    HttpApiClient.Client<Groups, never, never>
-  >()(id) as any
-
-  const layer = Layer.effect(
-    self,
-    HttpApiClient.make(options.api, options)
-  )
-  const runtimeFactory = options.runtime ?? Atom.runtime
-  self.runtime = runtimeFactory(
-    typeof options.httpClient === "function" ?
-      (get) =>
-        Layer.provide(
-          layer,
-          (options.httpClient as (get: Atom.AtomContext) => Layer.Layer<
-            | HttpApiGroup.ClientServices<Groups>
-            | HttpClient.HttpClient
-          >)(get)
-        ) as Layer.Layer<Self> :
-      Layer.provide(layer, options.httpClient) as Layer.Layer<Self>
-  )
+export const Service =
+  <Self>() =>
+  <const Id extends string, ApiId extends string, Groups extends HttpApiGroup.Constraint>(
+    id: Id,
+    options: {
+      readonly api: HttpApi.HttpApi<ApiId, Groups>
+      readonly httpClient:
+        | Layer.Layer<
+          | HttpApiGroup.ClientServices<Groups>
+          | HttpClient.HttpClient
+        >
+        | ((get: Atom.AtomContext) => Layer.Layer<
+          | HttpApiGroup.ClientServices<Groups>
+          | HttpClient.HttpClient
+        >)
+      readonly transformClient?: ((client: HttpClient.HttpClient) => HttpClient.HttpClient) | undefined
+      readonly transformResponse?:
+        | ((effect: Effect.Effect<unknown, unknown, unknown>) => Effect.Effect<unknown, unknown, unknown>)
+        | undefined
+      readonly baseUrl?: URL | string | undefined
+      readonly runtime?: Atom.RuntimeFactory | undefined
+    }
+  ): AtomHttpApiClient<Self, Id, Groups> => {
+    const self: Mutable<AtomHttpApiClient<Self, Id, Groups>> = Context.Service<
+      Self,
+      HttpApiClient.Client<Groups, never, never>
+    >()(id) as any
 
-  const catchErrors = Effect.catch((e: unknown) =>
-    Schema.isSchemaError(e) || HttpClientError.isHttpClientError(e) ? Effect.die(e) : Effect.fail(e)
-  )
+    const layer = Layer.effect(
+      self,
+      HttpApiClient.make(options.api, options)
+    )
+    const runtimeFactory = options.runtime ?? Atom.runtime
+    self.runtime = runtimeFactory(
+      typeof options.httpClient === "function" ?
+        (get) =>
+          Layer.provide(
+            layer,
+            (options.httpClient as (get: Atom.AtomContext) => Layer.Layer<
+              | HttpApiGroup.ClientServices<Groups>
+              | HttpClient.HttpClient
+            >)(get)
+          ) as Layer.Layer<Self> :
+        Layer.provide(layer, options.httpClient) as Layer.Layer<Self>
+    )
 
-  const mutationFamily = Atom.family(({ endpoint, group, responseMode }: MutationKey) => {
-    const atom = self.runtime.fn<{
-      params: any
-      query: any
-      headers: any
-      payload: any
-      reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined
-    }>()(
-      Effect.fnUntraced(function*(opts) {
-        const client = (yield* self) as any
-        const effect = catchErrors(client[group][endpoint]({
-          ...opts,
-          responseMode
-        }) as Effect.Effect<any>)
-        return yield* opts.reactivityKeys
-          ? Reactivity.mutation(effect, opts.reactivityKeys)
-          : effect
-      })
+    const catchErrors = Effect.catch((e: unknown) =>
+      Schema.isSchemaError(e) || HttpClientError.isHttpClientError(e) ? Effect.die(e) : Effect.fail(e)
     )
-    if (responseMode === "decoded-only") {
-      const definition = options.api.groups[group]!.endpoints[endpoint]! as HttpApiEndpoint.AnyWithProps
-      return Atom.serializable(atom, {
-        key: `AtomHttpApi:mutation:${group}:${endpoint}`,
-        schema: AsyncResult.Schema({
-          success: Schema.Union(HttpApiEndpoint.getSuccessSchemas(definition)),
-          error: Schema.Union(HttpApiEndpoint.getErrorSchemas(definition))
-        }) as any
-      })
-    }
-    return atom
-  }) as any
+    const groups = options.api.groups as unknown as Record<string, HttpApiGroup.Top>
 
-  self.mutation = ((group: string, endpoint: string, options?: {
-    readonly responseMode?: HttpApiEndpoint.ClientResponseMode | undefined
-  }) =>
-    mutationFamily({
-      group,
-      endpoint,
-      responseMode: options?.responseMode ?? "decoded-only"
-    })) as any
+    const mutationFamily = Atom.family(({ endpoint, group, responseMode }: MutationKey) => {
+      const atom = self.runtime.fn<{
+        params: any
+        query: any
+        headers: any
+        payload: any
+        reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined
+      }>()(
+        Effect.fnUntraced(function*(opts) {
+          const client = (yield* self) as any
+          const effect = catchErrors(client[group][endpoint]({
+            ...opts,
+            responseMode
+          }) as Effect.Effect<any>)
+          return yield* opts.reactivityKeys
+            ? Reactivity.mutation(effect, opts.reactivityKeys)
+            : effect
+        })
+      )
+      if (responseMode === "decoded-only") {
+        const definition = groups[group].endpoints[endpoint]
+        return Atom.serializable(atom, {
+          key: `AtomHttpApi:mutation:${group}:${endpoint}`,
+          schema: AsyncResult.Schema({
+            success: Schema.Union(HttpApiEndpoint.getSuccessSchemas(definition)),
+            error: Schema.Union(HttpApiEndpoint.getErrorSchemas(definition))
+          }) as any
+        })
+      }
+      return atom
+    }) as any
 
-  const queryFamily = Atom.family((opts: QueryKey) => {
-    let atom = self.runtime.atom(self.use((client_) => {
-      const client = client_ as any
-      return catchErrors(client[opts.group][opts.endpoint](opts) as Effect.Effect<
-        any,
-        HttpClientError.HttpClientError | SchemaError
-      >)
-    }))
-    if (opts.responseMode === "decoded-only" && opts.serializationKey) {
-      const endpoint = options.api.groups[opts.group]!.endpoints[opts.endpoint]! as HttpApiEndpoint.AnyWithProps
-      atom = Atom.serializable(atom, {
-        key: `AtomHttpApi:${opts.group}:${opts.endpoint}:${opts.serializationKey}`,
-        schema: AsyncResult.Schema({
-          success: Schema.Union(HttpApiEndpoint.getSuccessSchemas(endpoint)),
-          error: Schema.Union(HttpApiEndpoint.getErrorSchemas(endpoint))
-        }) as any
-      })
-    }
-    if (opts.timeToLive) {
-      atom = Duration.isFinite(opts.timeToLive)
-        ? Atom.setIdleTTL(atom, opts.timeToLive)
-        : Atom.keepAlive(atom)
-    }
-    return opts.reactivityKeys
-      ? self.runtime.factory.withReactivity(opts.reactivityKeys)(atom)
-      : atom
-  })
+    self.mutation = ((group: string, endpoint: string, options?: {
+      readonly responseMode?: HttpApiEndpoint.ClientResponseMode | undefined
+    }) =>
+      mutationFamily({
+        group,
+        endpoint,
+        responseMode: options?.responseMode ?? "decoded-only"
+      })) as any
 
-  self.query = ((
-    group: string,
-    endpoint: string,
-    request: {
-      readonly params?: any
-      readonly query?: any
-      readonly payload?: any
-      readonly headers?: any
-      readonly responseMode?: HttpApiEndpoint.ClientResponseMode
-      readonly reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined
-      readonly timeToLive?: Duration.Input | undefined
-      readonly serializationKey?: string | undefined
-    }
-  ) => {
-    const key: QueryKey = {
-      group,
-      endpoint,
-      params: request.params,
-      query: request.query,
-      payload: request.payload,
-      headers: request.headers,
-      responseMode: request.responseMode ?? "decoded-only",
-      reactivityKeys: request.reactivityKeys,
-      timeToLive: request.timeToLive
-        ? Duration.fromInputUnsafe(request.timeToLive)
-        : undefined,
-      serializationKey: request.serializationKey
-    }
-    return queryFamily(key)
-  }) as any
+    const queryFamily = Atom.family((opts: QueryKey) => {
+      let atom = self.runtime.atom(self.use((client_) => {
+        const client = client_ as any
+        return catchErrors(client[opts.group][opts.endpoint](opts) as Effect.Effect<
+          any,
+          HttpClientError.HttpClientError | SchemaError
+        >)
+      }))
+      if (opts.responseMode === "decoded-only" && opts.serializationKey) {
+        const endpoint = groups[opts.group].endpoints[opts.endpoint]
+        atom = Atom.serializable(atom, {
+          key: `AtomHttpApi:${opts.group}:${opts.endpoint}:${opts.serializationKey}`,
+          schema: AsyncResult.Schema({
+            success: Schema.Union(HttpApiEndpoint.getSuccessSchemas(endpoint)),
+            error: Schema.Union(HttpApiEndpoint.getErrorSchemas(endpoint))
+          }) as any
+        })
+      }
+      if (opts.timeToLive) {
+        atom = Duration.isFinite(opts.timeToLive)
+          ? Atom.setIdleTTL(atom, opts.timeToLive)
+          : Atom.keepAlive(atom)
+      }
+      return opts.reactivityKeys
+        ? self.runtime.factory.withReactivity(opts.reactivityKeys)(atom)
+        : atom
+    })
 
-  return self as AtomHttpApiClient<Self, Id, Groups>
-}
+    self.query = ((
+      group: string,
+      endpoint: string,
+      request: {
+        readonly params?: any
+        readonly query?: any
+        readonly payload?: any
+        readonly headers?: any
+        readonly responseMode?: HttpApiEndpoint.ClientResponseMode
+        readonly reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined
+        readonly timeToLive?: Duration.Input | undefined
+        readonly serializationKey?: string | undefined
+      }
+    ) => {
+      const key: QueryKey = {
+        group,
+        endpoint,
+        params: request.params,
+        query: request.query,
+        payload: request.payload,
+        headers: request.headers,
+        responseMode: request.responseMode ?? "decoded-only",
+        reactivityKeys: request.reactivityKeys,
+        timeToLive: request.timeToLive
+          ? Duration.fromInputUnsafe(request.timeToLive)
+          : undefined,
+        serializationKey: request.serializationKey
+      }
+      return queryFamily(key)
+    }) as any
+
+    return self as AtomHttpApiClient<Self, Id, Groups>
+  }
 
 interface MutationKey {
   group: string

package/src/unstable/reactivity/AtomRegistry.ts

@@ -96,8 +96,8 @@ export interface AtomRegistry {
 export interface Node<A> {
   readonly atom: Atom.Atom<A>
   readonly value: () => A
-  parents: Array<Node<any>>
-  children: Array<Node<any>>
+  parents: Set<Node<any>>
+  children: Set<Node<any>>
   listeners: Set<() => void>
   currentState(): "uninitialized" | "stale" | "valid" | "removed"
 }
@@ -713,10 +713,10 @@ class NodeImpl<A> {
   writeContext: WriteContextImpl<A>
   preserveInitialValueOnBuild = false
 
-  parents: Array<NodeImpl<any>> = []
-  previousParents: Array<NodeImpl<any>> | undefined
-  children: Array<NodeImpl<any>> = []
-  listeners: Set<() => void> = new Set()
+  parents = new Set<NodeImpl<any>>()
+  previousParents: Set<NodeImpl<any>> | undefined
+  children = new Set<NodeImpl<any>>()
+  listeners = new Set<() => void>()
   skipInvalidation = false
 
   currentState() {
@@ -733,7 +733,7 @@ class NodeImpl<A> {
   }
 
   get canBeRemoved(): boolean {
-    return !this.atom.keepAlive && this.listeners.size === 0 && this.children.length === 0 && this.state !== 0
+    return !this.atom.keepAlive && this.listeners.size === 0 && this.children.size === 0 && this.state !== 0
   }
 
   _value: A = undefined as any
@@ -753,10 +753,10 @@ class NodeImpl<A> {
       if (this.previousParents) {
         const parents = this.previousParents
         this.previousParents = undefined
-        for (let i = 0; i < parents.length; i++) {
-          parents[i].removeChild(this)
-          if (parents[i].canBeRemoved) {
-            this.registry.scheduleNodeRemoval(parents[i])
+        for (const parent of parents) {
+          parent.removeChild(this)
+          if (parent.canBeRemoved) {
+            this.registry.scheduleNodeRemoval(parent)
           }
         }
       }
@@ -826,19 +826,16 @@ class NodeImpl<A> {
   }
 
   addParent(parent: NodeImpl<any>): void {
-    this.parents.push(parent)
+    this.parents.add(parent)
     if (this.previousParents !== undefined) {
-      const index = this.previousParents.indexOf(parent)
-      if (index !== -1) {
-        this.previousParents[index] = this.previousParents[this.previousParents.length - 1]
-        if (this.previousParents.pop() === undefined) {
-          this.previousParents = undefined
-        }
+      this.previousParents.delete(parent)
+      if (this.previousParents.size === 0) {
+        this.previousParents = undefined
       }
     }
 
-    if (parent.children.indexOf(this) === -1) {
-      parent.children.push(this)
+    if (!parent.children.has(this)) {
+      parent.children.add(this)
       if (parent.skipInvalidation) {
         parent.skipInvalidation = false
       }
@@ -846,11 +843,7 @@ class NodeImpl<A> {
   }
 
   removeChild(child: NodeImpl<any>): void {
-    const index = this.children.indexOf(child)
-    if (index !== -1) {
-      this.children[index] = this.children[this.children.length - 1]
-      this.children.pop()
-    }
+    this.children.delete(child)
   }
 
   invalidate(): void {
@@ -870,14 +863,14 @@ class NodeImpl<A> {
   }
 
   invalidateChildren(): void {
-    if (this.children.length === 0) {
+    if (this.children.size === 0) {
       return
     }
 
     const children = this.children
-    this.children = []
-    for (let i = 0; i < children.length; i++) {
-      children[i].invalidate()
+    this.children = new Set()
+    for (const child of children) {
+      child.invalidate()
     }
   }
 
@@ -895,9 +888,9 @@ class NodeImpl<A> {
       this.lifetime = undefined
     }
 
-    if (this.parents.length !== 0) {
+    if (this.parents.size !== 0) {
       this.previousParents = this.parents
-      this.parents = []
+      this.parents = new Set()
     }
   }
 
@@ -917,10 +910,10 @@ class NodeImpl<A> {
 
     const parents = this.previousParents
     this.previousParents = undefined
-    for (let i = 0; i < parents.length; i++) {
-      parents[i].removeChild(this)
-      if (parents[i].canBeRemoved) {
-        this.registry.removeNode(parents[i])
+    for (const parent of parents) {
+      parent.removeChild(this)
+      if (parent.canBeRemoved) {
+        this.registry.removeNode(parent)
       }
     }
   }
@@ -931,19 +924,18 @@ class NodeImpl<A> {
   }
 }
 
-function childrenAreActive(children: Array<NodeImpl<any>>): boolean {
-  if (children.length === 0) {
+function childrenAreActive(children: Set<NodeImpl<any>>): boolean {
+  if (children.size === 0) {
     return false
   }
-  let current: Array<NodeImpl<any>> | undefined = children
-  let stack: Array<Array<NodeImpl<any>>> | undefined
+  let current: Set<NodeImpl<any>> | undefined = children
+  let stack: Array<Set<NodeImpl<any>>> | undefined
   let stackIndex = 0
   while (current !== undefined) {
-    for (let i = 0, len = current.length; i < len; i++) {
-      const child = current[i]
+    for (const child of current) {
       if (!child.atom.lazy || child.listeners.size > 0) {
         return true
-      } else if (child.children.length > 0) {
+      } else if (child.children.size > 0) {
         if (stack === undefined) {
           stack = [child.children]
         } else {
@@ -1233,8 +1225,7 @@ function batchRebuildNode(node: NodeImpl<any>) {
     return
   }
 
-  for (let i = 0; i < node.parents.length; i++) {
-    const parent = node.parents[i]
+  for (const parent of node.parents) {
     if (parent.state !== NodeState.valid) {
       batchRebuildNode(parent)
     }

package/src/unstable/rpc/RpcClient.ts

@@ -204,7 +204,7 @@ export declare namespace RpcClient {
  */
 export type FromGroup<Group, E = never> = RpcClient<RpcGroup.Rpcs<Group>, E>
 
-let requestIdCounter = BigInt(0)
+let requestIdCounter = 0
 
 /**
  * Creates an RPC client for an already-decoded message channel, returning the
@@ -681,7 +681,7 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
             Effect.flatMap((payload) =>
               send(clientId, {
                 ...message,
-                id: String(message.id),
+                id: message.id,
                 payload,
                 headers: Object.entries(message.headers)
               }, collector && collector.readUnsafe())
@@ -693,7 +693,7 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
           if (!entry) return Effect.void
           return send(clientId, {
             _tag: "Ack",
-            requestId: String(message.requestId)
+            requestId: message.requestId
           }) as Effect.Effect<void, RpcClientError>
         }
         case "Interrupt": {
@@ -702,7 +702,7 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
           entries.delete(message.requestId)
           return send(clientId, {
             _tag: "Interrupt",
-            requestId: String(message.requestId)
+            requestId: message.requestId
           }) as Effect.Effect<void, RpcClientError>
         }
         case "Eof": {
@@ -1030,7 +1030,7 @@ export const makeProtocolSocket = (options?: {
     const socket = yield* Socket.Socket
     const serialization = yield* RpcSerialization.RpcSerialization
     const hooks = yield* Effect.serviceOption(ConnectionHooks)
-    const requestClientMap = new Map<string, number>()
+    const requestClientMap = new Map<string | number, number>()
 
     const write = yield* socket.writer
 
@@ -1150,9 +1150,10 @@ export const makeProtocolSocket = (options?: {
     }
   }))
 
-const defaultRetryPolicy = Schedule.exponential(500, 1.5).pipe(
-  Schedule.either(Schedule.spaced(5000))
-)
+const defaultRetryPolicy = Schedule.min([
+  Schedule.exponential(500, 1.5),
+  Schedule.spaced(5000)
+])
 
 const makePinger = Effect.fnUntraced(function*<A, E, R>(writePing: Effect.Effect<A, E, R>) {
   let recievedPong = true
@@ -1224,7 +1225,7 @@ export const makeProtocolWorker = (
     const initialMessage = yield* Effect.serviceOption(RpcWorker.InitialMessage)
     const hooks = yield* Effect.serviceOption(ConnectionHooks)
 
-    const entries = new Map<string, {
+    const entries = new Map<string | number, {
       readonly clientId: number
       readonly worker: Worker.Worker<FromServerEncoded, FromClientEncoded | RpcWorker.InitialMessage.Encoded>
       readonly latch: Latch.Latch