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

package/src/store/commits.ts

@@ -1,9 +1,10 @@
-import { CommitFailed, CommitState, CommitTimeout, DEFAULT_COMMIT_TIMEOUT, WorkcardNotFound } from '@owlmeans/planning'
-import type { CommitEvent, CommitFilter, CommitStatus, Unsubscribe, Workcard } from '@owlmeans/planning'
+import { logger } from '@owlmeans/log'
+import { CommitFailed, CommitState, CommitTimeout, DEFAULT_COMMIT_TIMEOUT, WorkcardNotFound, type CommitEvent, type CommitFilter, type CommitStatus, type Unsubscribe, type Workcard } from '@owlmeans/planning'
 import { COMMIT_POLL_LADDER, DEFAULT_COMMIT_MEMORY } from '../consts.js'
 import type { CommitHub, CommitHubOptions } from './types.js'
+import type { Listener } from './types.local.js'
 
-type Listener = (event: CommitEvent) => void | Promise<void>
+const log = logger('planning:store')
 
 const matches = (event: CommitEvent, filter?: CommitFilter): boolean =>
   filter == null || (
@@ -58,7 +59,7 @@ export const makeCommitHub = (options: CommitHubOptions): CommitHub => {
       const results = await Promise.allSettled(targets.map(async entry => await entry.listener(event)))
       results.forEach(result => {
         if (result.status === 'rejected') {
-          console.error('planning: commit listener failed:', result.reason)
+          log.error('Planning commit listener failed', { transition: event.transition, error: result.reason })
         }
       })
     },

package/src/store/composite.ts

@@ -3,9 +3,9 @@ import type {
   CommitSource, PlanningStore, ProjectionStore, Relationship, RelationshipStore, SpecificationStore,
   TransitionStore, Unsubscribe, Workcard,
 } from '@owlmeans/planning'
-import { applyQuery } from '@owlmeans/resource'
 import type { Criteria, ListResult } from '@owlmeans/resource'
 import type { CommitHub, StoreRoute } from './types.js'
+import { recordQueryHelper } from '@owlmeans/resource'
 
 const firstOf = async <S, T>(
   stores: S[], read: (store: S) => Promise<T | null | undefined> | undefined
@@ -29,6 +29,7 @@ const sum = async <S>(stores: S[], run: (store: S) => Promise<number>): Promise<
  * then each owner; a list whose criteria names one owned type (or several owned by one store) goes
  * there, and every other list is the default store's — a cross-type query is answered by the
  * default store alone, never merged. Relationship lists and commit subscriptions span every store.
+ * The data-defined schema port is the default store's.
  */
 export const makeCompositeStore = (routes: StoreRoute[], fallback: PlanningStore): PlanningStore => {
   const all = [...new Set([fallback, ...routes.map(route => route.store)])]
@@ -121,7 +122,7 @@ export const makeCompositeStore = (routes: StoreRoute[], fallback: PlanningStore
     list: async (where, opts) => {
       const results = await Promise.all(linked.map(store => store.links!.list(where, { size: 0 })))
       const items = results.flatMap((result: ListResult<Relationship>) => result.items)
-      return applyQuery(items, undefined, opts)
+      return recordQueryHelper.applyQuery(items, undefined, opts)
     },
     put: link => (fallback.links ?? linked[0].links!).put(link),
     drop: where => sum(linked, store => store.links!.drop(where)),
@@ -162,10 +163,14 @@ export const makeCompositeStore = (routes: StoreRoute[], fallback: PlanningStore
   return {
     alias: `composite:${fallback.alias ?? 'default'}`,
     newId: fallback.newId,
+    unit: fallback.unit,
+    assignees: fallback.assignees, teams: fallback.teams, comments: fallback.comments, mentions: fallback.mentions,
     cards,
     ...(transitions != null ? { transitions } : {}),
     ...(specs != null ? { specs } : {}),
     ...(links != null ? { links } : {}),
     ...(commits != null ? { commits } : {}),
+    // Data-defined schemas are the default store's alone: a layer describes the whole organization.
+    ...(fallback.schemas != null ? { schemas: fallback.schemas } : {}),
   }
 }

package/src/store/consts.local.ts

@@ -0,0 +1 @@
+export const CONTENT_KEYS = ['body', 'ref', 'format', 'version'] as const

package/src/store/fold/types.ts

@@ -0,0 +1,44 @@
+import type { CommitEvent, CommitState, PlanningStore, SpecificationRevision, Transition, Workcard } from '@owlmeans/planning'
+import type { FoldOptions, FoldResult } from '../types.js'
+
+/** The projection body every store reuses: the fold of a card's pending log, and what it publishes. */
+export interface FoldHelper {
+  /** The event a settled transition publishes. `record` is in-process only — strip it before a bus. */
+  commitEventOf: (
+    transition: Transition, state: CommitState, at: string, extra?: { error?: string, record?: Workcard | null }
+  ) => CommitEvent
+  /**
+   * Fold every pending transition of one card — the projection body every store reuses.
+   *
+   * Transitions are read in `seq` order past the card's own `seq`, and only `pending` ones are
+   * applied, each with `applyHelper.applyTransition` and nothing else. Per transition: write the
+   * record (a `delete` drops it with its own documents, a project `delete` purges everything under it), fold its
+   * relationships, mark it `committed`, `publish` the event, then run `onCommitted` — so the `after`
+   * chain runs in THIS process, exactly once per committed transition. A transition that cannot be
+   * folded is marked `failed` with the reason and a failed event is published, and the fold goes PAST
+   * it: the card's `seq` advances to the failed transition with every other value as it was, so the
+   * next transition applies normally. Nothing is removed from the log. A create that fails leaves no
+   * card to advance, so what follows it fails too; a store that refuses the advancing write itself
+   * stops the fold there and reports `followUp`, leaving the rest pending for a retry.
+   *
+   * The caller owns single flight: two folds of one card running at once would both publish. A
+   * transactional store passes `unit`, which wraps each transition's writes (a savepoint), so a write
+   * the database refuses is undone whole before the fold marks the transition failed.
+   *
+   * @throws {PlanningUnsupported} for a store without a transition log
+   */
+  foldPending: (store: PlanningStore, cardId: string, entityId: string, opts?: FoldOptions) => Promise<FoldResult>
+  /**
+   * Mark every pending transition of a card `failed` and publish a failed event for each — what a
+   * queued store does when its projection job is dead, or waiters hang until their timeout.
+   */
+  failPending: (
+    store: PlanningStore, cardId: string, entityId: string, reason: string, opts?: Pick<FoldOptions, 'publish' | 'now'>
+  ) => Promise<number>
+  /**
+   * A specification's history, replayed from its log: one entry per create and per committed
+   * content change, newest first. The fold is `applyHelper.applyTransition` itself, so an entry's
+   * `body` is the body AT that revision even when the transition changed only `ref`.
+   */
+  revisionsFromLog: (log: Transition[], limit?: number) => SpecificationRevision[]
+}

package/src/store/fold.ts

@@ -1,10 +1,10 @@
-import {
-  applyRelationship, applyTransition, CommitState, isProject, PlanningUnsupported, TransitionAction,
-} from '@owlmeans/planning'
-import type {
-  CommitEvent, PlanningStore, Relationship, SpecificationRevision, Transition, Workcard,
-} from '@owlmeans/planning'
+import { logger } from '@owlmeans/log'
+import { applyHelper, cardHelper, CommitState, PlanningUnsupported, TransitionAction, type CommitEvent, type PlanningStore, type Relationship, type SpecificationRevision, type Transition, type Workcard } from '@owlmeans/planning'
+import type { FoldHelper } from './fold/types.js'
 import type { FoldOptions, FoldResult } from './types.js'
+import { CONTENT_KEYS } from './consts.local.js'
+
+const log = logger('planning:store')
 
 const isoNow = (): string => new Date().toISOString()
 
@@ -14,244 +14,246 @@ const clean = <T extends object>(record: T): T =>
 const errorText = (error: unknown): string =>
   error instanceof Error ? error.message : `${error}`
 
-const safely = async (label: string, run: () => Promise<void> | void | undefined): Promise<void> => {
-  try {
-    await run()
-  } catch (error) {
-    console.error(`planning: ${label} failed:`, error)
+export const createFoldHelper = (): FoldHelper => {
+  const safely = async (label: string, run: () => Promise<void> | void | undefined): Promise<void> => {
+    try {
+      await run()
+    } catch (error) {
+      log.error('Planning store step failed', { step: label, error })
+    }
   }
-}
 
-/** The event a settled transition publishes. `record` is in-process only — strip it before a bus. */
-export const commitEventOf = (
-  transition: Transition, state: CommitState, at: string, extra?: { error?: string, record?: Workcard | null }
-): CommitEvent => clean({
-  transition: transition.id!,
-  card: transition.card,
-  entityId: transition.entityId,
-  project: transition.project,
-  kind: transition.kind,
-  type: transition.type,
-  seq: transition.seq,
-  action: transition.action,
-  state,
-  at,
-  error: extra?.error,
-  record: extra?.record,
-})
+  const commitEventOf = (
+    transition: Transition, state: CommitState, at: string, extra?: { error?: string, record?: Workcard | null }
+  ): CommitEvent => clean({
+    transition: transition.id!,
+    card: transition.card,
+    entityId: transition.entityId,
+    project: transition.project,
+    kind: transition.kind,
+    type: transition.type,
+    seq: transition.seq,
+    action: transition.action,
+    state,
+    at,
+    error: extra?.error,
+    record: extra?.record,
+  })
 
-const bearsRelationships = (transition: Transition): boolean =>
-  transition.action === TransitionAction.Link
-  || transition.action === TransitionAction.Unlink
-  || transition.action === TransitionAction.Delete
-  || (transition.action === TransitionAction.Create && (transition.links?.length ?? 0) > 0)
+  const bearsRelationships = (transition: Transition): boolean =>
+    transition.action === TransitionAction.Link
+    || transition.action === TransitionAction.Unlink
+    || transition.action === TransitionAction.Delete
+    || (transition.action === TransitionAction.Create && (transition.links?.length ?? 0) > 0)
 
-const foldRelationships = async (store: PlanningStore, transition: Transition): Promise<void> => {
-  const links = store.links
-  if (links == null || !bearsRelationships(transition)) {
-    return
-  }
-  const where = { entityId: transition.entityId }
-  const [outgoing, incoming] = await Promise.all([
-    links.list({ ...where, from: transition.card }, { size: 0 }),
-    links.list({ ...where, to: transition.card }, { size: 0 }),
-  ])
-  const before = [...new Map([...outgoing.items, ...incoming.items].map(link => [link.id, link])).values()]
-  const after = applyRelationship(before, transition)
-  const kept = new Set(after.filter(link => link.id != null).map(link => link.id))
+  const foldRelationships = async (store: PlanningStore, transition: Transition): Promise<void> => {
+    const links = store.links
+    if (links == null || !bearsRelationships(transition)) {
+      return
+    }
+    const where = { entityId: transition.entityId }
+    const [outgoing, incoming] = await Promise.all([
+      links.list({ ...where, from: transition.card }, { size: 0 }),
+      links.list({ ...where, to: transition.card }, { size: 0 }),
+    ])
+    const before = [...new Map([...outgoing.items, ...incoming.items].map(link => [link.id, link])).values()]
+    const after = applyHelper.applyRelationship(before, transition)
+    const kept = new Set(after.filter(link => link.id != null).map(link => link.id))
 
-  for (const link of before) {
-    if (link.id != null && !kept.has(link.id)) {
-      await links.drop({ entityId: transition.entityId, id: link.id })
+    for (const link of before) {
+      if (link.id != null && !kept.has(link.id)) {
+        await links.drop({ entityId: transition.entityId, id: link.id })
+      }
     }
-  }
-  for (const link of after) {
-    if (link.id == null) {
-      await links.put(link as Relationship)
+    for (const link of after) {
+      if (link.id == null) {
+        await links.put(link as Relationship)
+      }
     }
   }
-}
 
-const writeFold = async (
-  store: PlanningStore, before: Workcard | null, after: Workcard | null, transition: Transition
-): Promise<void> => {
-  if (transition.action === TransitionAction.Delete) {
-    if (before != null && isProject(before)) {
-      // A project takes everything under it, its own log included — the hub remembers the commit.
-      await store.cards.purge(transition.card, transition.entityId)
+  const writeFold = async (
+    store: PlanningStore, before: Workcard | null, after: Workcard | null, transition: Transition
+  ): Promise<void> => {
+    await store.validateProjection?.(before, after, transition)
+    if (transition.action === TransitionAction.Delete) {
+      if (before != null && cardHelper.isProject(before)) {
+        // A project takes everything under it, its own log included — the hub remembers the commit.
+        await store.cards.purge(transition.card, transition.entityId)
+        return
+      }
+      await foldRelationships(store, transition)
+      await store.cards.drop(transition.card, transition.entityId)
       return
     }
+    if (after != null) {
+      await store.cards.put(after)
+      await store.projectReferences?.(after, transition)
+    }
     await foldRelationships(store, transition)
-    await store.cards.drop(transition.card, transition.entityId)
-    return
-  }
-  if (after != null) {
-    await store.cards.put(after)
   }
-  await foldRelationships(store, transition)
-}
-
-/**
- * Fold every pending transition of one card — the projection body every store reuses.
- *
- * Transitions are read in `seq` order past the card's own `seq`, and only `pending` ones are
- * applied, each with `applyTransition` and nothing else. Per transition: write the record (a
- * `delete` drops it, a project `delete` purges everything under it), fold its relationships, mark
- * it `committed`, `publish` the event, then run `onCommitted` — so the `after` chain runs in THIS
- * process, exactly once per committed transition. A transition that cannot be folded is marked
- * `failed` with the reason and a failed event is published, and the fold goes PAST it: the card's
- * `seq` advances to the failed transition with every other value as it was, so the next
- * transition applies normally. Nothing is removed from the log. A create that fails leaves no card
- * to advance, so what follows it fails too; a store that refuses the advancing write itself stops
- * the fold there and reports `followUp`, leaving the rest pending for a retry.
- *
- * The caller owns single flight: two folds of one card running at once would both publish.
- *
- * @throws {PlanningUnsupported} for a store without a transition log
- */
-export const foldPending = async (
-  store: PlanningStore, cardId: string, entityId: string, opts: FoldOptions = {}
-): Promise<FoldResult> => {
-  const transitions = store.transitions
-  if (transitions == null) {
-    throw new PlanningUnsupported(`fold:${store.alias ?? 'store'}`)
-  }
-  const now = opts.now ?? isoNow
-
-  let card = await store.cards.get(cardId, entityId)
-  const listed = await transitions.list(
-    { entityId, card: cardId, sinceSeq: card?.seq ?? 0, state: CommitState.Pending },
-    { sort: ['seq'], size: opts.limit ?? 0 }
-  )
 
-  let folded = 0
-  let failed = 0
-  for (const transition of listed.items) {
-    if (transition.commit.state !== CommitState.Pending || transition.id == null) {
-      continue
+  const foldPending = async (
+    store: PlanningStore, cardId: string, entityId: string, opts: FoldOptions = {}
+  ): Promise<FoldResult> => {
+    const transitions = store.transitions
+    if (transitions == null) {
+      throw new PlanningUnsupported(`fold:${store.alias ?? 'store'}`)
     }
-    await opts.touch?.()
-    const at = now()
+    const now = opts.now ?? isoNow
 
-    let next: Workcard | null
-    try {
-      next = applyTransition(card, transition)
-      if (card != null && next === card) {
-        // Already applied by another folder, which owns its commit and its event.
+    let card = await store.cards.get(cardId, entityId)
+    const listed = await transitions.list(
+      { entityId, card: cardId, sinceSeq: card?.seq ?? 0, state: CommitState.Pending },
+      { sort: ['seq'], size: opts.limit ?? 0 }
+    )
+
+    let folded = 0
+    let failed = 0
+    for (const transition of listed.items) {
+      if (transition.commit.state !== CommitState.Pending || transition.id == null) {
         continue
       }
-      await writeFold(store, card, next, transition)
-    } catch (error) {
-      failed++
-      const message = errorText(error)
-      if (card != null && transition.seq > card.seq) {
-        // Fold PAST it: the record keeps its previous values and only its cursor moves, so the
-        // next transition still applies. The card is re-written whole, which also undoes a write
-        // that got half way before it threw.
-        const skipped: Workcard = { ...card, seq: transition.seq, head: Math.max(card.head ?? card.seq, transition.seq) }
-        try {
-          await store.cards.put(skipped)
-          card = skipped
-        } catch (advance) {
-          // The store itself refuses writes: leave the rest pending for a retry rather than
-          // failing every later transition as out of order.
-          console.error(`planning: cannot advance ${cardId} past failed seq ${transition.seq}:`, advance)
-          await safely('commit failure', () => transitions.commit(transition.id!, { state: CommitState.Failed, at, error: message }))
-          await safely('publish', () => opts.publish?.(commitEventOf(transition, CommitState.Failed, at, { error: message })))
-          return { card, folded, failed, followUp: true }
+      await opts.touch?.()
+      const at = now()
+
+      let next: Workcard | null
+      try {
+        next = applyHelper.applyTransition(card, transition)
+        if (card != null && next === card) {
+          // Already applied by another folder, which owns its commit and its event.
+          continue
         }
+        const before = card
+        const after = next
+        await (opts.unit != null
+          ? opts.unit(async () => { await writeFold(store, before, after, transition) })
+          : writeFold(store, before, after, transition))
+      } catch (error) {
+        failed++
+        const message = errorText(error)
+        if (card != null && transition.seq > card.seq) {
+          // Fold PAST it: the record keeps its previous values and only its cursor moves, so the
+          // next transition still applies. The card is re-written whole, which also undoes a write
+          // that got half way before it threw.
+          const skipped: Workcard = { ...card, seq: transition.seq, head: Math.max(card.head ?? card.seq, transition.seq) }
+          try {
+            await store.cards.put(skipped)
+            card = skipped
+          } catch (advance) {
+            // The store itself refuses writes: leave the rest pending for a retry rather than
+            // failing every later transition as out of order.
+            log.error('Planning cannot advance a card past a failed transition', { cardId, seq: transition.seq, error: advance })
+            await safely('commit failure', () => transitions.commit(transition.id!, { state: CommitState.Failed, at, error: message }))
+            await safely('publish', () => opts.publish?.(commitEventOf(transition, CommitState.Failed, at, { error: message })))
+            return { card, folded, failed, followUp: true }
+          }
+        }
+        await safely('commit failure', () => transitions.commit(transition.id!, { state: CommitState.Failed, at, error: message }))
+        const event = commitEventOf(transition, CommitState.Failed, at, { error: message })
+        await safely('publish', () => opts.publish?.(event))
+        continue
       }
-      await safely('commit failure', () => transitions.commit(transition.id!, { state: CommitState.Failed, at, error: message }))
-      const event = commitEventOf(transition, CommitState.Failed, at, { error: message })
+
+      card = next
+      folded++
+      await safely('commit', () => transitions.commit(transition.id!, { state: CommitState.Committed, at }))
+      const event = commitEventOf(transition, CommitState.Committed, at, { record: next })
       await safely('publish', () => opts.publish?.(event))
-      continue
+      await safely('onCommitted', () => opts.onCommitted?.(event))
     }
 
-    card = next
-    folded++
-    await safely('commit', () => transitions.commit(transition.id!, { state: CommitState.Committed, at }))
-    const event = commitEventOf(transition, CommitState.Committed, at, { record: next })
-    await safely('publish', () => opts.publish?.(event))
-    await safely('onCommitted', () => opts.onCommitted?.(event))
+    return { card, folded, failed, followUp: listed.total > listed.items.length }
   }
 
-  return { card, folded, failed, followUp: listed.total > listed.items.length }
-}
+  const failPending = async (
+    store: PlanningStore, cardId: string, entityId: string, reason: string,
+    opts: Pick<FoldOptions, 'publish' | 'now'> = {}
+  ): Promise<number> => {
+    const transitions = store.transitions
+    if (transitions == null) {
+      return 0
+    }
+    const at = (opts.now ?? isoNow)()
+    const pending = await transitions.list({ entityId, card: cardId, state: CommitState.Pending }, { sort: ['seq'], size: 0 })
+    for (const transition of pending.items) {
+      if (transition.id == null) {
+        continue
+      }
+      await transitions.commit(transition.id, { state: CommitState.Failed, at, error: reason })
+      const event = commitEventOf(transition, CommitState.Failed, at, { error: reason })
+      await safely('publish', () => opts.publish?.(event))
+    }
 
-/**
- * Mark every pending transition of a card `failed` and publish a failed event for each — what a
- * queued store does when its projection job is dead, or waiters hang until their timeout.
- */
-export const failPending = async (
-  store: PlanningStore, cardId: string, entityId: string, reason: string,
-  opts: Pick<FoldOptions, 'publish' | 'now'> = {}
-): Promise<number> => {
-  const transitions = store.transitions
-  if (transitions == null) {
-    return 0
+    return pending.items.length
   }
-  const at = (opts.now ?? isoNow)()
-  const pending = await transitions.list({ entityId, card: cardId, state: CommitState.Pending }, { sort: ['seq'], size: 0 })
-  for (const transition of pending.items) {
-    if (transition.id == null) {
-      continue
+
+  const revisionsFromLog = (log: Transition[], limit?: number): SpecificationRevision[] => {
+    const ordered = log.filter(transition => transition.commit.state !== CommitState.Pending)
+      .sort((left, right) => left.seq - right.seq)
+
+    const entries: SpecificationRevision[] = []
+    let state: Workcard | null = null
+    for (const transition of ordered) {
+      if (transition.commit.state === CommitState.Failed) {
+        // The fold went past it; so does the replay.
+        if (state != null && transition.seq > state.seq) {
+          state = { ...(state as Workcard), seq: transition.seq }
+        }
+        continue
+      }
+      try {
+        state = applyHelper.applyTransition(state, transition)
+      } catch {
+        break
+      }
+      if (state == null) {
+        break
+      }
+      const changed = transition.action === TransitionAction.Create
+        || CONTENT_KEYS.some(key => (transition.changes as Record<string, unknown>)[key] !== undefined
+          || transition.unset?.includes(key) === true)
+      if (!changed) {
+        continue
+      }
+      const spec = state as Workcard & { body?: string, ref?: string, bodyChars?: number, version?: number, revision?: number }
+      entries.push(clean({
+        revision: spec.revision ?? entries.length + 1,
+        body: spec.body,
+        ref: spec.ref,
+        bodyChars: spec.bodyChars,
+        version: spec.version,
+        at: transition.at,
+        by: transition.actor,
+        transition: transition.id!,
+      }))
     }
-    await transitions.commit(transition.id, { state: CommitState.Failed, at, error: reason })
-    const event = commitEventOf(transition, CommitState.Failed, at, { error: reason })
-    await safely('publish', () => opts.publish?.(event))
+
+    const newest = entries.reverse()
+    return limit != null && limit > 0 ? newest.slice(0, limit) : newest
   }
 
-  return pending.items.length
+  return { commitEventOf, foldPending, failPending, revisionsFromLog }
 }
 
-const CONTENT_KEYS = ['body', 'ref', 'format', 'version'] as const
+export const foldHelper = createFoldHelper()
 
-/**
- * A specification's history, replayed from its log: one entry per create and per committed
- * content change, newest first. The fold is `applyTransition` itself, so an entry's `body` is the
- * body AT that revision even when the transition changed only `ref`.
- */
-export const revisionsFromLog = (log: Transition[], limit?: number): SpecificationRevision[] => {
-  const ordered = log.filter(transition => transition.commit.state !== CommitState.Pending)
-    .sort((left, right) => left.seq - right.seq)
+/** @deprecated compat:factory-refactor — use `foldHelper.commitEventOf(…)` */
+export const commitEventOf = (
+  transition: Transition, state: CommitState, at: string, extra?: { error?: string, record?: Workcard | null }
+): CommitEvent => foldHelper.commitEventOf(transition, state, at, extra)
 
-  const entries: SpecificationRevision[] = []
-  let state: Workcard | null = null
-  for (const transition of ordered) {
-    if (transition.commit.state === CommitState.Failed) {
-      // The fold went past it; so does the replay.
-      if (state != null && transition.seq > state.seq) {
-        state = { ...(state as Workcard), seq: transition.seq }
-      }
-      continue
-    }
-    try {
-      state = applyTransition(state, transition)
-    } catch {
-      break
-    }
-    if (state == null) {
-      break
-    }
-    const changed = transition.action === TransitionAction.Create
-      || CONTENT_KEYS.some(key => (transition.changes as Record<string, unknown>)[key] !== undefined
-        || transition.unset?.includes(key) === true)
-    if (!changed) {
-      continue
-    }
-    const spec = state as Workcard & { body?: string, ref?: string, bodyChars?: number, version?: number, revision?: number }
-    entries.push(clean({
-      revision: spec.revision ?? entries.length + 1,
-      body: spec.body,
-      ref: spec.ref,
-      bodyChars: spec.bodyChars,
-      version: spec.version,
-      at: transition.at,
-      by: transition.actor,
-      transition: transition.id!,
-    }))
-  }
+/** @deprecated compat:factory-refactor — use `foldHelper.foldPending(…)` */
+export const foldPending = async (
+  store: PlanningStore, cardId: string, entityId: string, opts: FoldOptions = {}
+): Promise<FoldResult> => await foldHelper.foldPending(store, cardId, entityId, opts)
 
-  const newest = entries.reverse()
-  return limit != null && limit > 0 ? newest.slice(0, limit) : newest
-}
+/** @deprecated compat:factory-refactor — use `foldHelper.failPending(…)` */
+export const failPending = async (
+  store: PlanningStore, cardId: string, entityId: string, reason: string,
+  opts: Pick<FoldOptions, 'publish' | 'now'> = {}
+): Promise<number> => await foldHelper.failPending(store, cardId, entityId, reason, opts)
+
+/** @deprecated compat:factory-refactor — use `foldHelper.revisionsFromLog(…)` */
+export const revisionsFromLog = (log: Transition[], limit?: number): SpecificationRevision[] =>
+  foldHelper.revisionsFromLog(log, limit)

package/src/store/index.ts

@@ -1,4 +1,5 @@
 export type * from './types.js'
+export type * from './fold/types.js'
 
 export * from './commits.js'
 export * from './composite.js'

package/src/store/types.local.ts

@@ -0,0 +1,3 @@
+import type { CommitEvent } from '@owlmeans/planning'
+
+export interface Listener { (event: CommitEvent): void | Promise<void> }

package/src/store/types.ts

@@ -1,6 +1,7 @@
 import type {
   CommitEvent, CommitSource, CommitStatus, PlanningStore, ProjectionStore, Relationship,
-  RelationshipStore, SpecificationStore, Transition, TransitionStore, Workcard,
+  RelationshipStore, SchemaStore, ScopedSchemaRecord, SpecificationStore, Transition, TransitionStore,
+  Workcard,
 } from '@owlmeans/planning'
 
 /** What a folding store calls for every committed transition — the service's `committed`. */
@@ -49,6 +50,11 @@ export interface FoldOptions {
   limit?: number
   /** Called between transitions — a queue processor renews its lock here. */
   touch?: () => Promise<void>
+  /**
+   * Runs one transition's store writes as a unit — a transactional store opens a savepoint here, so
+   * a write the database refuses leaves nothing of that transition behind and the fold goes past it.
+   */
+  unit?: <R>(run: () => Promise<R>) => Promise<R>
 }
 
 export interface FoldResult {
@@ -63,6 +69,8 @@ export interface MemoryPlanningStoreSeed {
   cards?: Workcard[]
   links?: Relationship[]
   transitions?: Transition[]
+  /** Data-defined type and flow records — kept only by a store built with `schemas: true`. */
+  schemas?: ScopedSchemaRecord[]
 }
 
 export interface MemoryPlanningStoreOptions {
@@ -74,6 +82,11 @@ export interface MemoryPlanningStoreOptions {
   /** The commit listener used until a service binds its own. */
   onCommitted?: CommitListener
   alias?: string
+  /**
+   * Hold data-defined types and flows (the `schemas` port). Off by default: a store without it
+   * resolves every type and flow from the code registry, exactly as before.
+   */
+  schemas?: boolean
 }
 
 export interface MemoryPlanningStore extends BindablePlanningStore {
@@ -82,6 +95,8 @@ export interface MemoryPlanningStore extends BindablePlanningStore {
   specs: SpecificationStore
   links: RelationshipStore
   commits: CommitHub
+  /** Present when the store was built with `schemas: true`. */
+  schemas?: SchemaStore
   bind: (committed: CommitListener) => void
   /** Fold what is pending — for one card, or for every card with a pending transition. */
   flush: (card?: string) => Promise<void>