@owlmeans/client-planning 0.1.18-rc.8 → 0.1.18

package/src/client.ts

@@ -2,12 +2,14 @@ import { bindAll } from '@owlmeans/client-entrypoint'
 import { createLazyService, MiddlewareStage, MiddlewareType } from '@owlmeans/context'
 import type { EntrypointTree } from '@owlmeans/entrypoint'
 import {
-  DEFAULT_PLUGIN_ORDER, makeSchemaRegistry, PLANNING_SERVICE, PlanningUnsupported,
+  appSchemaHelper, DEFAULT_PLUGIN_ORDER, makeSchemaRegistry, PLANNING_SERVICE, PlanningUnsupported,
 } from '@owlmeans/planning'
-import type { PlanningFacade, PlanningPlugin, PlanningSchemaRegistry } from '@owlmeans/planning'
+import type { PlanningAppDeclarations, PlanningFacade, PlanningPlugin, PlanningSchemaRegistry } from '@owlmeans/planning'
 import { makeRemoteCommitSource } from './commits.js'
+import { makeRemoteDefinitions } from './definitions.js'
 import { makeRemoteFacade } from './facade.js'
-import { planningStoresOf } from './stores.js'
+import { planningContextOf } from './helper.js'
+import { makePlanningClientLifecycle } from './lifecycle.js'
 import type {
   Config, Context, PlanningClientOptions, PlanningClientService, WithPlanningClient,
 } from './types.js'
@@ -19,40 +21,60 @@ import type {
  * What only a server can do is refused rather than faked: a client runs no middleware and folds
  * nothing, so `store()`, `committed()` and a plugin carrying hooks or a store answer
  * `PlanningUnsupported`. A plugin carrying only schemas is accepted — it layers over the server's
- * bundle.
+ * bundle (its `schemas.app` merged over the served declarations, in plugin order).
  */
 export const makePlanningClientService = <C extends Config, T extends Context<C>>(
   context: T, options: PlanningClientOptions
 ): PlanningClientService => {
+  const feeds = new Set<import('./types.js').PlanningFeed>()
   const registry = makeSchemaRegistry()
   const plugins: PlanningPlugin[] = []
-  const stores = () => planningStoresOf(context)
+  const stores = () => planningContextOf(context).stores()
+  const lifecycle = makePlanningClientLifecycle({ scopeKey: options.scopeKey, clear: async () => {
+    const mirrors = stores()
+    if (mirrors != null) for (const resource of Object.values(mirrors)) {
+      const rows = await resource.list({}, { size: 0 })
+      for (const row of rows.items) await resource.delete(row.id!)
+    }
+  } })
+  const scopeKey = lifecycle.key
 
   const commits = makeRemoteCommitSource(context, options.protocols, {
-    socket: options.socket, poll: options.poll, timeout: options.timeout, stores,
+    socket: options.socket, poll: options.poll, timeout: options.timeout, stores, lifecycle,
   })
 
-  const layerPlugins = (): void => plugins.forEach(plugin => {
-    plugin.schemas?.flows?.forEach(registry.registerFlow)
-    plugin.schemas?.types?.forEach(registry.registerType)
-  })
+  // The application's declarations the server served — what every client plugin's `app` merges over.
+  let served: PlanningAppDeclarations | undefined
+  const layerPlugins = (): void => {
+    registry.registerApp(appSchemaHelper.merge([served, ...plugins.map(plugin => plugin.schemas?.app)]))
+    plugins.forEach(plugin => {
+      plugin.schemas?.assigneeTypes?.forEach(registry.registerAssigneeType)
+      plugin.schemas?.flows?.forEach(registry.registerFlow)
+      plugin.schemas?.types?.forEach(registry.registerType)
+    })
+  }
 
+  let loadedKey = scopeKey()
   let loaded = false
   let loading: Promise<PlanningSchemaRegistry> | null = null
 
   const loadSchemas: PlanningClientService['loadSchemas'] = async opts => {
+    const key = scopeKey()
+    if (loadedKey !== key) { loaded = false; loading = null; definitions?.invalidate(); loadedKey = key }
     if (loaded && opts?.force !== true) {
       return registry
     }
     if (loading == null || opts?.force === true) {
-      const attempt = (async () => {
-        const bundle = await context.entrypoint(options.protocols.schema.list).call({ timeout: options.timeout })
+      const attempt = lifecycle.run(async operation => {
+        const bundle = await operation.wait(context.entrypoint(options.protocols.schema.list).call({ timeout: options.timeout, signal: operation.signal }))
+        operation.check()
         registry.load(bundle)
+        served = registry.app()
         layerPlugins()
         loaded = true
 
         return registry
-      })()
+      })
       loading = attempt
       // A failed load is forgotten, so the next caller asks again instead of inheriting the error.
       attempt.catch(() => {
@@ -65,16 +87,32 @@ export const makePlanningClientService = <C extends Config, T extends Context<C>
     return await loading
   }
 
+  // A write of data-defined schemas moves the organization's bundle too: the next `model()` reloads it.
+  const definitions = options.protocols.schema.define == null
+    ? undefined
+    : makeRemoteDefinitions(context, options.protocols, { lifecycle, timeout: options.timeout, onWrite: () => { loaded = false; loading = null } })
+
   const facadeFor = (scope: Parameters<PlanningClientService['for']>[0]): PlanningFacade =>
     makeRemoteFacade(context, options.protocols, { ...options.scope, ...scope }, {
-      commits, schemas: registry, loadSchemas, timeout: options.timeout, stores,
+      commits, schemas: registry, loadSchemas, scopeKey, lifecycle, timeout: options.timeout, stores,
+      ...(definitions != null ? { definitions } : {}),
     })
 
   let fallback: PlanningFacade | null = null
+  lifecycle.onInvalidate(async () => {
+    const stopping = [...feeds]
+    feeds.clear()
+    loaded = false; loading = null; definitions?.invalidate()
+    registry.load({ version: 1, types: [], flows: [] }); served = undefined; layerPlugins()
+    await Promise.all(stopping.map(async feed => await feed.stop()))
+  })
 
   // Lazy, like the server's host: `context.planning()` answers before the context initializes.
   return createLazyService<PlanningClientService>(PLANNING_SERVICE, {
     schemas: registry,
+    lifecycle,
+    scopeKey,
+    registerFeed: feed => { feeds.add(feed); return () => { feeds.delete(feed) } },
 
     commits,
 
@@ -84,6 +122,9 @@ export const makePlanningClientService = <C extends Config, T extends Context<C>
       if (plugin.before != null || plugin.after != null || plugin.store != null || plugin.mintCode != null) {
         throw new PlanningUnsupported(`client:plugin:${plugin.name}`)
       }
+      if (plugin.schemas?.app != null) {
+        appSchemaHelper.assertDeclarations(plugin.schemas.app)
+      }
       const existing = plugins.findIndex(candidate => candidate.name === plugin.name)
       if (existing >= 0) {
         plugins.splice(existing, 1)
@@ -105,7 +146,9 @@ export const makePlanningClientService = <C extends Config, T extends Context<C>
       throw new PlanningUnsupported('client:committed')
     },
 
-    close: async () => await commits.close(),
+    close: lifecycle.close,
+
+    ...(definitions != null ? { definitions } : {}),
   })
 }
 

package/src/commits.ts

@@ -1,247 +1,215 @@
 import type { BasicConfig, BasicContext } from '@owlmeans/context'
-import {
-  CommitFailed, CommitState, CommitTimeout, DEFAULT_COMMIT_POLL, DEFAULT_COMMIT_TIMEOUT, MAX_COMMIT_POLL,
-  PLANNING_COMMIT_EVENT, PlanningError, WorkcardKind,
-} from '@owlmeans/planning'
-import type {
-  CommitEvent, CommitFilter, CommitStatus, PlanningProtocols, Unsubscribe, Workcard,
-} from '@owlmeans/planning'
+import { logger } from '@owlmeans/log'
+import { planningReplyHelper, CommitFailed, CommitState, CommitTimeout, DEFAULT_COMMIT_POLL, DEFAULT_COMMIT_TIMEOUT, MAX_COMMIT_POLL, PLANNING_COMMIT_EVENT, PlanningError, WorkcardKind, type CommitEvent, type CommitFilter, type CommitStatus, type PlanningProtocols, type Unsubscribe, type Workcard } from '@owlmeans/planning'
 import type { Connection } from '@owlmeans/socket'
 import { EARLY_POLL_LADDER, EARLY_POLL_MS, LONG_POLL_GRACE } from './consts.js'
+import { makePlanningClientLifecycle } from './lifecycle.js'
+import type { PlanningOperation } from './lifecycle/types.js'
 import type { RemoteCommitSource, RemoteCommitSourceOptions } from './types.js'
-import { dropCard, putCard, putCommit } from './utils/record.js'
+import type { CommitSocketOpening, Subscription } from './types.local.js'
+import { recordUtils } from './utils/record.js'
 
-interface Subscription {
-  listener: (event: CommitEvent) => void | Promise<void>
-  filter?: CommitFilter
-}
-
-const matches = (filter: CommitFilter | undefined, event: CommitEvent): boolean =>
-  filter == null || (
-    (filter.entityId == null || filter.entityId === event.entityId)
-    && (filter.project == null || filter.project === event.project)
-    && (filter.card == null || filter.card === event.card)
-    && (filter.kind == null || filter.kind === event.kind)
-  )
-
-const delay = (ms: number): { promise: Promise<void>, cancel: () => void } => {
-  let handle: ReturnType<typeof setTimeout> | undefined
-  const promise = new Promise<void>(resolve => { handle = setTimeout(resolve, Math.max(0, ms)) })
+const log = logger('client-planning')
 
-  return { promise, cancel: () => clearTimeout(handle) }
-}
-
-/**
- * The commit source of a remote facade: the `commit.get` long poll and, when the host injects a
- * socket opener, the `commit.events` feed.
- *
- * `wait` SUBSCRIBES FIRST and only then reads the status — a commit landing between a read and a
- * subscription would otherwise be missed until the deadline. It then long-polls in holds of
- * `min(poll, remaining)` seconds, so a client with no socket (a Node connector) still learns of a
- * commit within one round trip of it landing, and a client with one learns from whichever arrives
- * first. The deadline is a {@link CommitTimeout}; the transition stays pending — nothing is undone.
- *
- * ONE socket serves every subscription of the source; releasing a subscription never closes it.
- */
+/** Subscribe before reading, then race the shared socket against bounded HTTP holds. */
 export const makeRemoteCommitSource = <C extends BasicConfig, T extends BasicContext<C>>(
   context: T, protocols: PlanningProtocols, opts?: RemoteCommitSourceOptions
 ): RemoteCommitSource => {
+  const lifecycle = opts?.lifecycle ?? makePlanningClientLifecycle({ scopeKey: opts?.scopeKey })
   const poll = Math.max(0, Math.min(MAX_COMMIT_POLL, opts?.poll ?? DEFAULT_COMMIT_POLL))
   const subscriptions = new Set<Subscription>()
-
-  let opening: Promise<Connection | null> | null = null
+  const operations = new Set<PlanningOperation>()
+  let opening: CommitSocketOpening | null = null
+  const openingOf = (): CommitSocketOpening | null => opening
   let open: Connection | null = null
   let detach: (() => void) | null = null
 
+  const capture = (): PlanningOperation => {
+    const captured = lifecycle.capture()
+    const operation: PlanningOperation = { ...captured, release: () => {
+      operations.delete(operation)
+      captured.release()
+    } }
+    operations.add(operation)
+    return operation
+  }
+  const matches = (filter: CommitFilter | undefined, event: CommitEvent): boolean => filter == null || (
+    (filter.entityId == null || filter.entityId === event.entityId)
+    && (filter.project == null || filter.project === event.project)
+    && (filter.card == null || filter.card === event.card)
+    && (filter.kind == null || filter.kind === event.kind)
+  )
+  const delay = (ms: number): { promise: Promise<void>, cancel: () => void } => {
+    let handle: ReturnType<typeof setTimeout> | undefined
+    const promise = new Promise<void>(resolve => { handle = setTimeout(resolve, Math.max(0, ms)) })
+    return { promise, cancel: () => clearTimeout(handle) }
+  }
   const dispatch = async (event: CommitEvent): Promise<void> => {
     for (const subscription of [...subscriptions]) {
-      if (!matches(subscription.filter, event)) {
-        continue
-      }
-      try {
-        await subscription.listener(event)
-      } catch (e) {
-        console.error('Planning commit listener error:', e)
-      }
+      if (!subscriptions.has(subscription) || !subscription.operation.active() || !matches(subscription.filter, event)) continue
+      try { await subscription.operation.wait(Promise.resolve(subscription.listener(event))) }
+      catch (error) { if (subscription.operation.active()) log.error('Planning commit listener failed', error) }
     }
   }
 
   const socket = async (): Promise<Connection | null> => {
     const opener = opts?.socket
-    if (opener == null) {
-      return null
-    }
-    opening ??= (async () => {
+    if (opener == null) return null
+    lifecycle.key() // Observe an identity change before reusing an open carrier.
+    if (open != null) return open
+    if (opening != null) return await opening.promise
+    const operation = capture()
+    const pending = (async () => {
       try {
-        const connection = await opener(protocols.commit.events, { query: {} })
-        if (connection == null) {
-          // No socket right now (not signed in yet, say) — the next subscription asks again.
-          opening = null
-          return null
-        }
-        open = connection
-        detach = connection.observe<CommitEvent>(PLANNING_COMMIT_EVENT, async message => {
-          await dispatch(message.payload)
+        const carrier = Promise.resolve().then(async () => {
+          operation.check()
+          return await opener(protocols.commit.events, { query: {}, signal: operation.signal })
+        }).then(async connection => {
+          if (connection == null) return null
+          if (!operation.active()) { await connection.close(); return null }
+          open = connection
+          detach = connection.observe<CommitEvent>(PLANNING_COMMIT_EVENT, async message => {
+            if (operation.active()) await dispatch(planningReplyHelper.hydrate<CommitEvent>(message.payload))
+          })
+          return connection
         })
-        return connection
-      } catch (e) {
-        opening = null
-        console.error('Planning commit socket error:', e)
+        return await operation.wait(carrier)
+      } catch (error) {
+        if (operation.active()) log.warn('Planning commit socket failed to open', error)
         return null
+      } finally {
+        if (openingOf()?.operation === operation) opening = null
+        // Keep an open carrier's operation cancellable until close; it guards received frames.
+        if (open == null || !operation.active()) operation.release()
       }
     })()
-
-    return await opening
+    opening = { operation, promise: pending }
+    return await pending
   }
 
   const endpoint = () => context.entrypoint(protocols.commit.get)
-
-  const status = async (transition: string): Promise<CommitStatus> => await endpoint().call({
-    params: { transition }, query: { wait: 0 }, timeout: opts?.timeout,
-  })
-
-  const hold = async (transition: string, wait: number, signal: AbortSignal): Promise<CommitStatus> => {
+  const status = async (transition: string, operation: PlanningOperation): Promise<CommitStatus> => {
+    operation.check()
+    return planningReplyHelper.hydrate<CommitStatus>(await operation.wait(endpoint().call({
+      params: { transition }, query: { wait: 0 }, timeout: opts?.timeout, signal: operation.signal,
+    })))
+  }
+  const hold = async (transition: string, wait: number, signal: AbortSignal, operation: PlanningOperation): Promise<CommitStatus> => {
+    operation.check()
     try {
-      return await endpoint().call({
+      return planningReplyHelper.hydrate<CommitStatus>(await operation.wait(endpoint().call({
         params: { transition }, query: { wait }, timeout: wait * 1000 + LONG_POLL_GRACE, signal,
-      })
-    } catch (e) {
-      if (signal.aborted || e instanceof PlanningError) {
-        throw e
-      }
-      // A dropped hold (a proxy closing an idle response) is not an answer about the commit: one
-      // non-holding read replaces it, and a failure of THAT is reported.
-      return await status(transition)
+      })))
+    } catch (error) {
+      operation.check()
+      if (signal.aborted || error instanceof PlanningError) throw error
+      // A dropped hold says nothing about the commit. Never retry it under another scope.
+      return await status(transition, operation)
     }
   }
-
-  /** Fold a settled status into the mirror, when the host registered one. */
-  const fold = async (transition: string, settled: CommitStatus): Promise<void> => {
+  const answer = async (transition: string, settled: CommitStatus, operation: PlanningOperation): Promise<Workcard | null> => {
     const stores = opts?.stores?.()
-    if (stores == null) {
-      return
-    }
-    const known = await stores.commits.load(transition)
-    await putCommit(stores.commits, {
-      id: transition, state: settled.state, at: settled.at, error: settled.error,
+    if (stores != null) await lifecycle.mutate(operation, async () => {
+      const known = await stores.commits.load(transition)
+      await recordUtils.putCommit(stores.commits, {
+        id: transition, state: settled.state, at: settled.at, error: settled.error,
+      })
+      if (settled.state === CommitState.Committed) {
+        if (settled.card != null) await recordUtils.putCard(stores.cards, settled.card)
+        else if (settled.card === null && known?.card != null) await recordUtils.dropCard(stores, known.card, known.kind === WorkcardKind.Project)
+      }
     })
-    if (settled.state !== CommitState.Committed) {
-      return
-    }
-    if (settled.card != null) {
-      await putCard(stores.cards, settled.card)
-    } else if (settled.card === null && known?.card != null) {
-      await dropCard(stores, known.card, known.kind === WorkcardKind.Project)
-    }
-  }
-
-  const answer = async (transition: string, settled: CommitStatus): Promise<Workcard | null> => {
-    await fold(transition, settled)
-    if (settled.state === CommitState.Failed) {
-      throw new CommitFailed(settled.error ?? transition)
-    }
-
+    operation.check()
+    if (settled.state === CommitState.Failed) throw new CommitFailed(settled.error ?? transition)
     return settled.card ?? null
   }
-
-  const subscribe = async (
-    listener: Subscription['listener'], filter?: CommitFilter
-  ): Promise<Unsubscribe> => {
-    const subscription: Subscription = { listener, filter }
+  const subscribe = async (listener: Subscription['listener'], filter?: CommitFilter, signal?: AbortSignal): Promise<Unsubscribe> => {
+    const operation = capture()
+    const subscription: Subscription = { listener, filter, operation }
     subscriptions.add(subscription)
-    await socket()
-
-    return () => { subscriptions.delete(subscription) }
+    const stop = (): void => {
+      subscriptions.delete(subscription); operation.cancel(); operation.release()
+      signal?.removeEventListener('abort', stop)
+    }
+    signal?.addEventListener('abort', stop, { once: true })
+    if (signal?.aborted) stop()
+    try { await operation.wait(socket()); return stop }
+    catch (error) { stop(); throw error }
   }
+  const close = async (): Promise<void> => {
+    for (const operation of operations) { operation.cancel(); operation.release() }
+    subscriptions.clear()
+    detach?.(); detach = null
+    const connection = open
+    open = null; opening = null
+    await Promise.all([connection?.close(), lifecycle.drain()])
+  }
+  lifecycle.onInvalidate(close)
 
-  const source: RemoteCommitSource = {
-    status,
-
+  return {
+    status: async transition => {
+      const operation = capture()
+      try { return await status(transition, operation) } finally { operation.release() }
+    },
     subscribe,
-
     wait: async (transition, waitOpts) => {
-      const deadline = Date.now() + (waitOpts?.timeout ?? DEFAULT_COMMIT_TIMEOUT)
-      // Held in an object: a frame writes it from a callback, which flow analysis cannot see.
+      const operation = capture()
+      const duration = waitOpts?.timeout ?? DEFAULT_COMMIT_TIMEOUT
+      const deadline = Date.now() + duration
+      const deadlineTimer = setTimeout(() => operation.cancel(new CommitTimeout(transition)), Math.max(0, duration))
       const frame: { landed: CommitEvent | null } = { landed: null }
-      let wake: () => void = () => { }
-      const unsubscribe = await subscribe(event => {
-        if (event.transition === transition && event.state !== CommitState.Pending) {
-          frame.landed = event
-          wake()
-        }
-      })
-
-      /** A frame says it settled; the status read carries the card when the frame does not. */
-      const fromFrame = async (event: CommitEvent): Promise<Workcard | null> => event.record !== undefined
-        ? await answer(transition, {
-          transition, state: event.state, at: event.at, error: event.error, card: event.record,
-        })
-        : await answer(transition, await status(transition))
-
+      let wake: () => void = () => {}
+      let unsubscribe: Unsubscribe | undefined
       try {
-        let current = await status(transition)
+        const subscribing = subscribe(event => {
+          if (operation.active() && event.transition === transition && event.state !== CommitState.Pending) { frame.landed = event; wake() }
+        }, undefined, operation.signal)
+        // A cancelled waiter must also release a subscription whose opener completes later.
+        void subscribing.then(stop => { if (!operation.active()) stop() }, () => {})
+        unsubscribe = await operation.wait(subscribing)
+        const fromFrame = async (event: CommitEvent): Promise<Workcard | null> => await answer(transition,
+          event.record !== undefined
+            ? { transition, state: event.state, at: event.at, error: event.error, card: event.record }
+            : await status(transition, operation), operation)
+        let current = await status(transition, operation)
         let early = 0
         while (current.state === CommitState.Pending) {
-          if (frame.landed != null) {
-            return await fromFrame(frame.landed)
-          }
+          operation.check()
+          if (frame.landed != null) return await fromFrame(frame.landed)
           const remaining = deadline - Date.now()
-          if (remaining <= 0) {
-            throw new CommitTimeout(transition)
-          }
-
+          if (remaining <= 0) throw new CommitTimeout(transition)
           const wait = Math.min(poll, Math.ceil(remaining / 1000))
           const abort = new AbortController()
+          const cancel = () => abort.abort(operation.signal.reason)
+          operation.signal.addEventListener('abort', cancel, { once: true })
           const timer = delay(remaining)
           const framed = new Promise<'frame'>(resolve => { wake = () => resolve('frame') })
           const started = Date.now()
           try {
-            const outcome = await Promise.race([
-              hold(transition, wait, abort.signal),
-              framed,
-              timer.promise.then(() => 'deadline' as const),
-            ])
-            if (outcome === 'frame' || outcome === 'deadline') {
-              continue
-            }
+            const outcome = await operation.wait(Promise.race([
+              hold(transition, wait, abort.signal, operation), framed, timer.promise.then(() => 'deadline' as const),
+            ]))
+            if (outcome === 'frame' || outcome === 'deadline') continue
             current = outcome
           } finally {
-            abort.abort()
-            timer.cancel()
-            wake = () => { }
+            abort.abort(); timer.cancel(); wake = () => {}
+            operation.signal.removeEventListener('abort', cancel)
           }
-
           if (current.state === CommitState.Pending && Date.now() - started < EARLY_POLL_MS) {
-            // The server did not hold — pause on a ladder rather than spin until the deadline.
-            const pause = delay(Math.min(
-              EARLY_POLL_LADDER[Math.min(early, EARLY_POLL_LADDER.length - 1)], deadline - Date.now()
-            ))
-            early += 1
-            await Promise.race([pause.promise, new Promise<void>(resolve => { wake = resolve })])
-            pause.cancel()
-            wake = () => { }
-          } else {
-            early = 0
-          }
+            const pause = delay(Math.min(EARLY_POLL_LADDER[Math.min(early, EARLY_POLL_LADDER.length - 1)], deadline - Date.now()))
+            early++
+            try { await operation.wait(Promise.race([pause.promise, new Promise<void>(resolve => { wake = resolve })])) }
+            finally { pause.cancel(); wake = () => {} }
+          } else early = 0
         }
-
-        return await answer(transition, current)
+        return await answer(transition, current, operation)
       } finally {
-        unsubscribe()
+        clearTimeout(deadlineTimer)
+        unsubscribe?.()
+        operation.cancel(); operation.release()
       }
     },
-
-    connected: () => open != null,
-
-    close: async () => {
-      detach?.()
-      detach = null
-      const connection = open
-      open = null
-      opening = null
-      await connection?.close()
-    },
+    connected: () => { lifecycle.key(); return open != null },
+    close,
   }
-
-  return source
 }

package/src/consts.ts

@@ -1,20 +1,28 @@
 import type { Relationship, Workcard } from '@owlmeans/planning'
-import { stateAlias } from '@owlmeans/state'
 import type { StateAlias } from '@owlmeans/state'
 import type { PlanningCommitRecord, PlanningStoreAliases } from './types.js'
 
+// A state alias is the string itself at runtime (`stateAlias()` only attaches the record type), so
+// each handle is declared as the constant it is.
+
 /**
  * The ONE card store. Projects, cards and specifications share an id space on the server, so they
  * share it here too — a store per kind would let a list reload of one kind drop another's rows.
  */
-export const CARDS: StateAlias<Workcard> = stateAlias<Workcard>('planning-card-state')
+export const CARDS = 'planning-card-state' as StateAlias<Workcard>
 
-export const LINKS: StateAlias<Relationship> = stateAlias<Relationship>('planning-link-state')
+export const LINKS = 'planning-link-state' as StateAlias<Relationship>
 
 /** What the client has learned about each transition it wrote or saw, keyed by transition id. */
-export const COMMITS: StateAlias<PlanningCommitRecord> = stateAlias<PlanningCommitRecord>('planning-commit-state')
+export const COMMITS = 'planning-commit-state' as StateAlias<PlanningCommitRecord>
+
+export const ASSIGNEES = 'planning-assignee-state' as StateAlias<import('@owlmeans/planning').Assignee>
+export const TEAMS = 'planning-team-state' as StateAlias<import('@owlmeans/planning').Team>
+export const COMMENTS = 'planning-comment-state' as StateAlias<import('@owlmeans/planning').Comment>
+export const MENTIONS = 'planning-mention-state' as StateAlias<import('@owlmeans/planning').CommentMention>
 
 export const DEFAULT_STORE_ALIASES: Readonly<PlanningStoreAliases> = Object.freeze({
+  assignees: ASSIGNEES, teams: TEAMS, comments: COMMENTS, mentions: MENTIONS,
   cards: CARDS,
   links: LINKS,
   commits: COMMITS,