@owlmeans/server-planning 0.1.18-rc.2 → 0.1.18-rc.21

package/src/facade.ts

@@ -1,14 +1,25 @@
-import {
-  criteriaOf, currentSpecification, isSpecification, linkWhereOf, listOptionsOf, modelOf,
-  PlanningUnsupported, specCriteriaOf, transitionWhereOf, WorkcardKind, WorkcardNotFound,
-} from '@owlmeans/planning'
-import type {
-  CommitSource, PlanningFacade, PlanningScope, Specification, Workcard, WorkcardModel,
-} from '@owlmeans/planning'
+import { criteriaOf, currentSpecification, isProject, isSpecification, linkWhereOf, listOptionsOf, modelOf, projectOf, PlanningUnsupported, specCriteriaOf, transitionWhereOf, WorkcardKind, WorkcardNotFound, type CommitEvent, type CommitSource, type PlanningFacade, type PlanningScope, type Relationship, type Specification, type Transition, type Workcard, type WorkcardModel, type WorkcardQuery } from '@owlmeans/planning'
+import type { Criteria } from '@owlmeans/resource'
+import { makeDefinitions } from './definitions.js'
 import { executeTransition } from './executor.js'
-import type { PlanningRuntime } from './service.js'
+import type { PlanningRuntime } from './types.js'
+import { wantsSpecifications } from './store/memory.js'
 import type { CommitHub } from './store/types.js'
 
+/**
+ * The criteria a scope narrowed to `projects` adds to every card list, count and summary: the
+ * projects themselves, every card whose `parents` name one of them, and the specifications whose
+ * parent card is one of `through` — the cards of those projects a specification is seen through,
+ * exactly as a single read sees it (a specification's `parents` hold only its own card).
+ */
+export const projectCriteriaOf = (projects: readonly string[], through: readonly string[] = []): Criteria<Workcard> => ({
+  $or: [
+    { id: { $in: [...projects] } },
+    { parents: { $overlaps: [...projects] } },
+    ...(through.length > 0 ? [{ kind: WorkcardKind.Specification, parent: { $in: [...through] } }] : []),
+  ],
+}) as Criteria<Workcard>
+
 /**
  * The scoped facade over the service's stores.
  *
@@ -16,13 +27,75 @@ import type { CommitHub } from './store/types.js'
  * a card of another entity is simply absent — `load` answers `null`, `get` throws
  * `WorkcardNotFound`, exactly as for an id that never existed. Reads go through the composite
  * store (the default store plus the stores plugins own); writes go through the executor.
+ *
+ * A scope naming `projects` sees those projects, the cards whose `parents` name one of them, and a
+ * specification whose parent card is one of those (a card's specification through its card);
+ * everything else reads as absent. Lists, counts and summaries are narrowed by an AND'd criteria
+ * that admits the same cards a single read does — the parent cards a specification is seen through
+ * are resolved once per call ({@link projectCriteriaOf}) — and commit events and transitions
+ * outside the set are dropped or refused.
+ *
+ * `definitions` is present when the default store holds data-defined schemas; a model is then
+ * built over the registry of the card's own project.
  */
 export const makeStoreFacade = (runtime: PlanningRuntime, scope: PlanningScope): PlanningFacade => {
   const entityId = scope.entityId
+  const projects = scope.projects != null ? [...new Set(scope.projects)] : undefined
   const reader = () => runtime.reader()
   const mine = <T extends { entityId: string }>(record: T | null | undefined): T | null =>
     record != null && record.entityId === entityId ? record : null
 
+  const inProjects = (card: Workcard): boolean => projects == null
+    || (card.id != null && projects.includes(card.id))
+    || card.parents.some(parent => projects.includes(parent))
+
+  /** A card this scope may see — a specification through its parent card. */
+  const visible = async (card: Workcard | null): Promise<Workcard | null> => {
+    if (card == null || inProjects(card)) {
+      return card
+    }
+    if (isSpecification(card) && card.parent != null) {
+      const parent = mine(await reader().cards.get(card.parent, entityId))
+      return parent != null && inProjects(parent) ? card : null
+    }
+    return null
+  }
+
+  /**
+   * The cards a narrowed list or count may see specifications THROUGH — what {@link visible} admits
+   * one by: its parent card in the scope's projects. One read per call, and only for criteria that
+   * ask for specifications at all (`wantsSpecifications`, the rule every store routes a list by): the
+   * parent the query names, or else the projects' own cards. A summary counts no specification.
+   */
+  const throughOf = async (where: Criteria<Workcard>, parent?: string): Promise<string[]> => {
+    if (projects == null || projects.length === 0 || !wantsSpecifications(where)) {
+      return []
+    }
+    if (parent != null) {
+      const card = mine(await reader().cards.get(parent, entityId))
+      return card != null && inProjects(card) ? [parent] : []
+    }
+    const listed = await reader().cards.list({ entityId, parents: { $overlaps: projects } } as unknown as Criteria<Workcard>, { size: 0 })
+    // A project's own specifications are matched by their `parents` already.
+    return listed.items.filter(card => card.id != null && !projects.includes(card.id) && inProjects(card)).map(card => card.id!)
+  }
+
+  /** A narrowed list's or count's criteria — `through` as {@link throughOf} resolved it. */
+  const narrowed = async (query?: WorkcardQuery | null): Promise<Criteria<Workcard>> => {
+    const where = criteriaOf(query, scope)
+    return narrow(where, await throughOf(where, query?.parent))
+  }
+
+  const narrow = (where: Criteria<Workcard>, through: readonly string[] = []): Criteria<Workcard> => projects == null
+    ? where
+    : {
+      ...where,
+      $and: [...((where as { $and?: Criteria<Workcard>[] }).$and ?? []), projectCriteriaOf(projects, through)],
+    } as Criteria<Workcard>
+
+  const projectVisible = (project?: string | null): boolean =>
+    projects == null || (project != null && projects.includes(project))
+
   const commitSource = (): CommitSource => {
     const commits = reader().commits
     if (commits == null) {
@@ -31,28 +104,37 @@ export const makeStoreFacade = (runtime: PlanningRuntime, scope: PlanningScope):
     return commits
   }
 
-  /** The transition is this entity's — its row, or the remembered commit of a purged one. */
+  /** The transition is this entity's (and this scope's) — its row, or the remembered commit of a purged one. */
   const assertTransition = async (transition: string): Promise<void> => {
     const row = await reader().transitions?.get(transition)
     if (row != null) {
-      if (row.entityId !== entityId) {
+      if (row.entityId !== entityId || !projectVisible(row.project)) {
         throw new WorkcardNotFound(`transition:${transition}`)
       }
       return
     }
     const recalled = (reader().commits as Partial<CommitHub> | undefined)?.recall?.(transition)
-    if (recalled == null || recalled.entityId !== entityId) {
+    if (recalled == null || recalled.entityId !== entityId || !projectVisible(recalled.project)) {
       throw new WorkcardNotFound(`transition:${transition}`)
     }
   }
 
+  /** The project a card resolves its data-defined types in. */
+  const projectFor = async (card: Workcard): Promise<string | undefined> => {
+    if (isProject(card) || card.parent == null) {
+      return projectOf(card)
+    }
+    const parent = mine(await reader().cards.get(card.parent, entityId))
+    return projectOf(card, parent)
+  }
+
   const facade: PlanningFacade = {
-    scope: Object.freeze({ ...scope }),
+    scope: Object.freeze({ ...scope, ...(projects != null ? { projects } : {}) }),
 
     schemas: runtime.service().schemas,
 
     cards: {
-      load: async id => mine(await reader().cards.get(id, entityId)),
+      load: async id => await visible(mine(await reader().cards.get(id, entityId))),
 
       get: async id => {
         const card = await facade.cards.load(id)
@@ -62,17 +144,20 @@ export const makeStoreFacade = (runtime: PlanningRuntime, scope: PlanningScope):
         return card
       },
 
-      list: async query => await reader().cards.list(criteriaOf(query, scope), listOptionsOf(query)),
+      list: async query => await reader().cards.list(await narrowed(query), listOptionsOf(query)),
 
-      count: async query => await reader().cards.count(criteriaOf(query, scope)),
+      count: async query => await reader().cards.count(await narrowed(query)),
 
       summary: async (parents, query) => parents.length === 0
         ? {}
-        : await reader().cards.summary(parents, criteriaOf({ kind: query?.kind, type: query?.type }, scope)),
+        : await reader().cards.summary(parents, narrow(criteriaOf({ kind: query?.kind, type: query?.type }, scope))),
     },
 
     specifications: {
       current: async (parent, category) => {
+        if (projects != null && await facade.cards.load(parent) == null) {
+          return null
+        }
         const specs = reader().specs
         if (specs != null) {
           return mine(await specs.current(parent, category, entityId))
@@ -82,6 +167,9 @@ export const makeStoreFacade = (runtime: PlanningRuntime, scope: PlanningScope):
       },
 
       list: async (parent, query) => {
+        if (projects != null && await facade.cards.load(parent) == null) {
+          return { items: [], total: 0 }
+        }
         const specs = reader().specs
         if (specs != null) {
           return await specs.list(parent, entityId, query)
@@ -110,16 +198,23 @@ export const makeStoreFacade = (runtime: PlanningRuntime, scope: PlanningScope):
     relationships: {
       list: async query => {
         const links = reader().links
-        return links == null
-          ? { items: [], total: 0 }
-          : await links.list(linkWhereOf(query, scope), listOptionsOf(query))
+        if (links == null) {
+          return { items: [], total: 0 }
+        }
+        if (projects == null) {
+          return await links.list(linkWhereOf(query, scope), listOptionsOf(query))
+        }
+        const listed = await links.list({ ...linkWhereOf(query, scope), project: projects }, listOptionsOf(query))
+        // A store that ignores `project` must still not leak an edge filed under another project.
+        const items = listed.items.filter((link: Relationship) => projectVisible(link.project))
+        return items.length === listed.items.length ? listed : { ...listed, items, total: listed.total - (listed.items.length - items.length) }
       },
     },
 
     transitions: {
       get: async id => {
         const transition = mine(await reader().transitions?.get(id))
-        if (transition == null) {
+        if (transition == null || !projectVisible(transition.project)) {
           throw new WorkcardNotFound(`transition:${id}`)
         }
         return transition
@@ -127,9 +222,20 @@ export const makeStoreFacade = (runtime: PlanningRuntime, scope: PlanningScope):
 
       list: async query => {
         const transitions = reader().transitions
-        return transitions == null
-          ? { items: [], total: 0 }
-          : await transitions.list(transitionWhereOf(query, scope), listOptionsOf(query))
+        if (transitions == null) {
+          return { items: [], total: 0 }
+        }
+        if (projects == null) {
+          return await transitions.list(transitionWhereOf(query, scope), listOptionsOf(query))
+        }
+        if (query.project != null && !projects.includes(query.project)) {
+          return { items: [], total: 0 }
+        }
+        const listed = await transitions.list(
+          { ...transitionWhereOf(query, scope), project: query.project ?? projects }, listOptionsOf(query)
+        )
+        const items = listed.items.filter((transition: Transition) => projectVisible(transition.project))
+        return items.length === listed.items.length ? listed : { ...listed, items, total: listed.total - (listed.items.length - items.length) }
       },
     },
 
@@ -139,7 +245,10 @@ export const makeStoreFacade = (runtime: PlanningRuntime, scope: PlanningScope):
         return await commitSource().status(transition)
       },
 
-      subscribe: (listener, filter) => commitSource().subscribe(listener, { ...filter, entityId }),
+      subscribe: (listener, filter) => commitSource().subscribe(projects == null
+        ? listener
+        : (event: CommitEvent) => projectVisible(event.project) ? listener(event) : undefined,
+      { ...filter, entityId }),
 
       wait: async (transition, opts) => {
         await assertTransition(transition)
@@ -154,9 +263,18 @@ export const makeStoreFacade = (runtime: PlanningRuntime, scope: PlanningScope):
       if (record.entityId !== entityId) {
         throw new WorkcardNotFound(record.id ?? WorkcardKind.Card)
       }
-      return modelOf<T>(record, facade)
+      if (runtime.schemaStore() == null) {
+        return modelOf<T>(record, facade)
+      }
+      // A data-defined type answers from the registry of the card's own project.
+      const schemas = await runtime.schemasFor(entityId, await projectFor(record))
+      return modelOf<T>(record, { ...facade, schemas })
     },
   }
 
+  if (runtime.schemaStore() != null) {
+    facade.definitions = makeDefinitions(runtime, facade)
+  }
+
   return facade
 }

package/src/helper.ts

@@ -3,7 +3,7 @@ import type { AbstractRequest } from '@owlmeans/entrypoint'
 import type { PlanningFacade, PlanningProtocols, PlanningScope } from '@owlmeans/planning'
 import { bind } from '@owlmeans/server-entrypoint'
 import {
-  executePlanning, getCard, getCommit, getSpecification, getTransition, listCardSpecifications,
+  defineSchemas, executePlanning, getCard, getCommit, getSpecification, getTransition, listCardSpecifications,
   listCardTransitions, listCards, listLinks, listSchemas, listSpecificationRevisions, summarizeCards,
   watchCommits,
 } from './actions/index.js'
@@ -12,12 +12,16 @@ import { planningServiceOf, scopeOf } from './utils/index.js'
 
 /**
  * Bind this package's handlers to a tree declared by `makePlanningProtocols` — one binding per
- * protocol, the base included. Pass the tree itself, never a flattened list; an application that
- * wants its own handler for one leaf binds that protocol afterwards.
+ * protocol, the base included (and `schema.define` when the tree declares it). Pass the tree
+ * itself, never a flattened list; an application that wants its own handler for one leaf binds
+ * that protocol afterwards.
  */
 export const servePlanningEntrypoints = (protocols: PlanningProtocols, opts?: PlanningHandlerOptions) => [
   bind(protocols.base),
   bind(protocols.schema.list, listSchemas(protocols.schema.list, opts)),
+  ...(protocols.schema.define != null
+    ? [bind(protocols.schema.define, defineSchemas(protocols.schema.define, opts))]
+    : []),
   bind(protocols.card.list, listCards(protocols.card.list, opts)),
   bind(protocols.card.summary, summarizeCards(protocols.card.summary, opts)),
   bind(protocols.card.get, getCard(protocols.card.get, opts)),

package/src/index.ts

@@ -5,6 +5,7 @@ export * from './consts.js'
 export * from './service.js'
 export * from './registry.js'
 export * from './facade.js'
+export * from './definitions.js'
 export * from './executor.js'
 export * from './helper.js'
 export * from './projection.js'

package/src/projection.ts

@@ -1,22 +1,12 @@
 import type { BasicConfig, BasicContext } from '@owlmeans/context'
-import { PLANNING_SERVICE } from '@owlmeans/planning'
-import type { CommitEvent, PlanningService, PlanningStore } from '@owlmeans/planning'
-import { PLANNING_PROJECT_JOB, PLANNING_PROJECTION_QUEUE } from './queue/index.js'
-import type { ProjectionRequest } from './queue/index.js'
+import { PLANNING_SERVICE, type PlanningService, type PlanningStore } from '@owlmeans/planning'
+import { PLANNING_PROJECT_JOB, PLANNING_PROJECTION_QUEUE } from './queue/consts.js'
+import type { ProjectionRequest } from './queue/types.js'
 import type { JobProcessor, QueueHooks } from '@owlmeans/queue'
 import { failPending, foldPending } from './store/fold.js'
-import type { PlanningHostService } from './types.js'
+import type { PlanningHostService, ProjectionOptions } from './types.js'
 import type { CommitHub, FoldResult } from './store/types.js'
 
-export interface ProjectionOptions {
-  /** The planning service alias. */
-  service?: string
-  /** The store the queue folds — the service's default store when omitted. */
-  store?: (service: PlanningService) => PlanningStore
-  /** Where events go — the store's commit hub `publish` when it has one. */
-  publish?: (event: CommitEvent) => Promise<void>
-}
-
 const serviceOf = (ctx: BasicContext<BasicConfig>, opts?: ProjectionOptions): PlanningService =>
   ctx.service<PlanningHostService>(opts?.service ?? PLANNING_SERVICE)
 

package/src/queue/consts.ts

@@ -0,0 +1,5 @@
+/** The server-side queue used to project planning transitions. */
+export const PLANNING_PROJECTION_QUEUE = 'planning-projection'
+
+/** The processor name accepted by the planning projection queue. */
+export const PLANNING_PROJECT_JOB = 'planning:project'

package/src/queue/index.ts

@@ -1,25 +1,10 @@
-import { declareQueue } from '@owlmeans/queue'
-import type { Config, JobOptions, QueueWorkerOptions } from '@owlmeans/queue'
-
-/** The server-side queue used to project planning transitions. */
-export const PLANNING_PROJECTION_QUEUE = 'planning-projection'
-
-/** The processor name accepted by the planning projection queue. */
-export const PLANNING_PROJECT_JOB = 'planning:project'
-
-/** What one projection job folds. */
-export interface ProjectionRequest {
-  cardId: string
-  entityId: string
-  /** The transition that requested projection; it is a hint rather than a fold bound. */
-  transition?: string
-}
-
-export interface PlanningQueueOptions {
-  worker?: QueueWorkerOptions
-  defaults?: JobOptions
-}
+import { declareQueue, type Config } from '@owlmeans/queue'
+import { PLANNING_PROJECT_JOB, PLANNING_PROJECTION_QUEUE } from './consts.js'
+import type { PlanningQueueOptions } from './types.js'
 
 /** Declare the shared projection address; each process separately chooses whether to listen. */
 export const declarePlanningQueue = <C extends Config>(cfg: C, opts?: PlanningQueueOptions): C =>
   declareQueue(cfg, PLANNING_PROJECTION_QUEUE, [PLANNING_PROJECT_JOB], opts)
+
+export { PLANNING_PROJECTION_QUEUE, PLANNING_PROJECT_JOB } from './consts.js'
+export type { PlanningQueueOptions, ProjectionRequest } from './types.js'

package/src/queue/types.ts

@@ -0,0 +1,14 @@
+import type { JobOptions, QueueWorkerOptions } from '@owlmeans/queue'
+
+/** What one projection job folds. */
+export interface ProjectionRequest {
+  cardId: string
+  entityId: string
+  /** The transition that requested projection; it is a hint rather than a fold bound. */
+  transition?: string
+}
+
+export interface PlanningQueueOptions {
+  worker?: QueueWorkerOptions
+  defaults?: JobOptions
+}

package/src/registry.ts

@@ -1,34 +1,10 @@
 import type { BasicConfig, BasicContext } from '@owlmeans/context'
 import { ResilientError } from '@owlmeans/error'
-import { DEFAULT_PLUGIN_ORDER, PlanningRefused } from '@owlmeans/planning'
-import type {
-  CommitEvent, PlanningExecContext, PlanningHookContext, PlanningPlugin, PlanningSchemaRegistry,
-  PlanningStore, TransitionExecution, WorkcardDraft,
-} from '@owlmeans/planning'
-import type { StoreRoute } from './store/types.js'
+import { logger } from '@owlmeans/log'
+import { DEFAULT_PLUGIN_ORDER, PlanningRefused, type PlanningPlugin, type PlanningSchemaRegistry, type PlanningStore } from '@owlmeans/planning'
+import type { PluginRegistry } from './types.js'
 
-export interface PluginRegistry {
-  /** Register, or replace the plugin of the same `name`. Its schemas are contributed now. */
-  use: (plugin: PlanningPlugin) => void
-  /** Every plugin, `order` ascending (registration order among equals). */
-  plugins: () => PlanningPlugin[]
-  /** The owning plugins that supply a store, in plugin order, each store resolved once. */
-  routes: (ctx?: BasicContext<BasicConfig>) => StoreRoute[]
-  /** The first owning plugin's store for a type, else `fallback`. */
-  storeFor: (type: string | undefined, fallback: PlanningStore, ctx?: BasicContext<BasicConfig>) => PlanningStore
-  /** The first plugin answering a code wins. */
-  mintCode: (
-    draft: WorkcardDraft, taken: (code: string) => Promise<boolean>, contextOf: (plugin: PlanningPlugin) => PlanningExecContext
-  ) => Promise<string | undefined>
-  /** The `before` chain; answers the execution the chain left. */
-  before: (
-    exec: TransitionExecution, contextOf: (plugin: PlanningPlugin) => PlanningExecContext
-  ) => Promise<TransitionExecution>
-  /** The `after` chain; a failing hook is logged and the chain goes on. */
-  after: (event: CommitEvent, contextOf: (plugin: PlanningPlugin) => PlanningHookContext) => Promise<void>
-  /** Bumps on every `use` — what a cached composite store is keyed by. */
-  version: () => number
-}
+const log = logger('planning')
 
 const messageOf = (error: unknown): string => error instanceof Error ? error.message : `${error}`
 
@@ -131,7 +107,7 @@ export const makePluginRegistry = (
         try {
           await plugin.after(event, contextOf(plugin))
         } catch (error) {
-          console.error(`planning: after hook of ${plugin.name} failed on ${event.transition}:`, error)
+          log.error('Planning after hook failed', { plugin: plugin.name, transition: event.transition, error })
         }
       }
     },

package/src/service.ts

@@ -1,29 +1,13 @@
-import { createLazyService } from '@owlmeans/context'
-import type { BasicConfig, BasicContext } from '@owlmeans/context'
-import { makeSchemaRegistry, PlanningError } from '@owlmeans/planning'
-import type { PlanningService, PlanningStore, Transition, WithPlanningService } from '@owlmeans/planning'
+import { createLazyService, type BasicConfig, type BasicContext } from '@owlmeans/context'
+import { makeSchemaRegistry, PlanningError, type PlanningService, type PlanningStore, type Transition, type WithPlanningService } from '@owlmeans/planning'
 import { DEFAULT_ALIAS } from './consts.js'
+import { makeSchemaViews } from './definitions.js'
 import { makeStoreFacade } from './facade.js'
 import { makePluginRegistry } from './registry.js'
-import type { PluginRegistry } from './registry.js'
 import { makeCompositeStore } from './store/composite.js'
 import { makeMemoryPlanningStore } from './store/memory.js'
 import type { BindablePlanningStore } from './store/types.js'
-import type { PlanningHostService, PlanningServiceOptions } from './types.js'
-
-export type PlanningServiceApi = Pick<PlanningService, 'use' | 'plugins' | 'schemas' | 'store' | 'for' | 'committed'>
-
-/** What the facade and the executor reach the service through. */
-export interface PlanningRuntime {
-  service: () => PlanningService
-  registry: PluginRegistry
-  options: PlanningServiceOptions
-  context: () => BasicContext<BasicConfig> | undefined
-  /** The composite store reads and commits go through. */
-  reader: () => PlanningStore
-  /** Every distinct store: the default one first, then each plugin's. */
-  stores: () => PlanningStore[]
-}
+import type { PlanningHostService, PlanningServiceOptions, PlanningRuntime, PlanningServiceApi } from './types.js'
 
 const contextOf = (service: PlanningService): BasicContext<BasicConfig> | undefined =>
   (service as Partial<PlanningHostService>).ctx as BasicContext<BasicConfig> | undefined
@@ -54,6 +38,12 @@ export const planningServiceApi = (
 
   let reader: { version: number, store: PlanningStore } | undefined
 
+  const views = makeSchemaViews({
+    code: () => schemas,
+    version: () => registry.version(),
+    port: () => fallback.schemas,
+  })
+
   const runtime: PlanningRuntime = {
     service: self,
     registry,
@@ -66,6 +56,9 @@ export const planningServiceApi = (
       return reader.store
     },
     stores: () => [...new Set([fallback, ...registry.routes(runtime.context()).map(route => route.store)])],
+    schemaStore: () => fallback.schemas,
+    schemasFor: views.of,
+    scopedSchemas: views.scoped,
   }
 
   options.plugins?.forEach(registry.use)

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

@@ -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)])]
@@ -167,5 +168,7 @@ export const makeCompositeStore = (routes: StoreRoute[], fallback: PlanningStore
     ...(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.ts

@@ -1,10 +1,9 @@
-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 { applyRelationship, applyTransition, CommitState, isProject, PlanningUnsupported, TransitionAction, type CommitEvent, type PlanningStore, type Relationship, type SpecificationRevision, type Transition, type Workcard } from '@owlmeans/planning'
 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()
 
@@ -18,7 +17,7 @@ const safely = async (label: string, run: () => Promise<void> | void | undefined
   try {
     await run()
   } catch (error) {
-    console.error(`planning: ${label} failed:`, error)
+    log.error('Planning store step failed', { step: label, error })
   }
 }
 
@@ -105,7 +104,9 @@ const writeFold = async (
  * 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.
+ * 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
  */
@@ -140,7 +141,11 @@ export const foldPending = async (
         // Already applied by another folder, which owns its commit and its event.
         continue
       }
-      await writeFold(store, card, next, transition)
+      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)
@@ -155,7 +160,7 @@ export const foldPending = async (
         } 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)
+          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 }
@@ -204,8 +209,6 @@ export const failPending = async (
   return pending.items.length
 }
 
-const CONTENT_KEYS = ['body', 'ref', 'format', 'version'] as const
-
 /**
  * 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

package/src/store/types.local.ts

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