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

package/src/actions/watch.ts

@@ -1,3 +1,4 @@
+import { logger } from '@owlmeans/log'
 import { PLANNING_COMMIT_EVENT } from '@owlmeans/planning'
 import type { CommitEvent, CommitFeedQuery, PlanningProtocols } from '@owlmeans/planning'
 import { connection } from '@owlmeans/server-socket'
@@ -6,6 +7,8 @@ import { MessageType } from '@owlmeans/socket'
 import type { Context, PlanningHandlerOptions } from '../types.js'
 import { handlerFacade } from '../utils/index.js'
 
+const log = logger('planning:watch')
+
 const text = (value: unknown): string | undefined =>
   value == null || value === '' ? undefined : `${value}`
 
@@ -32,7 +35,7 @@ export const watchCommits = (
       const enriched = event.record !== undefined ? event : { ...event, record: await facade.cards.load(event.card) }
       await conn.notify(frame, enriched)
     } catch (e) {
-      console.error('Planning commit notify error:', e)
+      log.warn('Planning commit notify failed', e)
     }
   }, filter)
 
@@ -45,7 +48,7 @@ export const watchCommits = (
       try {
         unsubscribe()
       } catch (e) {
-        console.error('Planning commit unsubscribe error:', e)
+        log.warn('Planning commit unsubscribe failed', e)
       }
     }
   })

package/src/conformance/cases.ts

@@ -1,35 +1,10 @@
 import { uuid } from '@owlmeans/basic-ids'
-import {
-  applyTransition, CardTypeNotAllowed, CommitState, IntrinsicStatus, PlanningError, PlanningSchemaKind,
-  RelationshipRefused, SchemaConflict, SchemaInUse, SchemaInvalid, SchemaOrigin, SchemaSealed, SpecificationFormat,
-  TransitionAction, UnknownWorkcardType, WorkcardConflict, WorkcardKind, WorkcardNotFound,
-} from '@owlmeans/planning'
-import type {
-  CommitEvent, PlanningFacade, PlanningService, PlanningStore, StatusFlowSchema, Transition, TransitionExecution,
-  Unsubscribe, Workcard, WorkcardQuery, WorkcardTypeSchema,
-} from '@owlmeans/planning'
+import { applyTransition, CardTypeNotAllowed, CommitState, IntrinsicStatus, PlanningError, PlanningSchemaKind, RelationshipRefused, SchemaConflict, SchemaInUse, SchemaInvalid, SchemaOrigin, SchemaSealed, SpecificationFormat, TransitionAction, UnknownWorkcardType, WorkcardConflict, WorkcardKind, WorkcardNotFound, type CommitEvent, type PlanningFacade, type PlanningStore, type StatusFlowSchema, type Transition, type TransitionExecution, type Unsubscribe, type Workcard, type WorkcardQuery, type WorkcardTypeSchema } from '@owlmeans/planning'
 import { creatorOf } from '../executor/creator.js'
 import { check, rejects, same, sameSet } from './assert.js'
-import { BOOK_TYPE, LIBRARY, PERIODICAL_TYPE, createBook, createBranch, transit } from './fixtures.js'
-
-/** What a case runs against: a planning service over the store under test. */
-export interface ConformanceSubject {
-  /** A service with `planningConformancePlugin` registered and a strictly increasing clock. */
-  service: PlanningService
-  /** The store under test — the service's default store. */
-  store: PlanningStore
-  /** A facade of one organization, acting as a signed-in person. */
-  facade: (entityId: string) => PlanningFacade
-}
-
-/** A capability a store may implement; a case that needs one is skipped for a store without it. */
-export type ConformanceCapability = 'schemas'
-
-export interface ConformanceCase {
-  name: string
-  needs?: ConformanceCapability[]
-  run: (subject: ConformanceSubject) => Promise<void>
-}
+import { createBook, createBranch, transit } from './fixtures.js'
+import { BOOK_TYPE, LIBRARY, PERIODICAL_TYPE } from './consts.js'
+import type { ConformanceCase } from './types.js'
 
 /** A fresh organization per case, so cases never see each other's cards on a shared database. */
 const organization = (): string => `conformance-${uuid()}`

package/src/conformance/consts.ts

@@ -0,0 +1,44 @@
+import { type WorkcardTypeSchema, CodeScope, CodeStyle, SpecificationFormat, WorkcardKind } from '@owlmeans/planning'
+
+/**
+ * The conformance vocabulary: a lending library. Branches (projects) hold books and periodicals
+ * (cards); a book runs a circulation flow and a review flow; documents are pages.
+ */
+export const LIBRARY = Object.freeze({
+  branch: 'library:branch',
+  room: 'library:reading-room',
+  book: 'library:book',
+  periodical: 'library:periodical',
+  page: 'library:page',
+  circulation: 'library:circulation',
+  review: 'library:review',
+  branchLife: 'library:branch-life',
+  pageLife: 'library:page-life',
+})
+
+export const BOOK_TYPE: WorkcardTypeSchema = {
+  type: LIBRARY.book,
+  kind: WorkcardKind.Card,
+  version: 1,
+  fields: {
+    type: 'object',
+    properties: { genre: { type: 'string', enum: ['poetry', 'history', 'fiction'] }, signed: { type: 'boolean' } },
+    additionalProperties: false,
+  },
+  flows: [LIBRARY.circulation, LIBRARY.review],
+  specifications: [{ category: 'summary', format: SpecificationFormat.Json, revisioned: true, keepRevisions: 3 }],
+  relationships: [{ name: 'sequel-of', to: [LIBRARY.book], single: true }, { name: 'shelved-near' }],
+  labels: ['rare', 'new', 'signed'],
+  code: { prefix: 'B-', style: CodeStyle.Random, length: 5, uppercase: true, uniqueWithin: CodeScope.Parent },
+}
+
+export const PERIODICAL_TYPE: WorkcardTypeSchema = {
+  type: LIBRARY.periodical,
+  kind: WorkcardKind.Card,
+  version: 1,
+  overridable: true,
+  label: 'Periodical',
+  fields: { type: 'object', additionalProperties: true },
+  flows: [LIBRARY.circulation],
+  specifications: [],
+}

package/src/conformance/fixtures.ts

@@ -1,26 +1,6 @@
-import {
-  CodeScope, CodeStyle, IntrinsicStatus, SpecificationFormat, TransitionAction, WorkcardKind,
-} from '@owlmeans/planning'
-import type {
-  AnyTypeSchema, PlanningFacade, PlanningPlugin, StatusFlowSchema, TransitionReceipt, Workcard,
-  WorkcardTypeSchema,
-} from '@owlmeans/planning'
-
-/**
- * The conformance vocabulary: a lending library. Branches (projects) hold books and periodicals
- * (cards); a book runs a circulation flow and a review flow; documents are pages.
- */
-export const LIBRARY = Object.freeze({
-  branch: 'library:branch',
-  room: 'library:reading-room',
-  book: 'library:book',
-  periodical: 'library:periodical',
-  page: 'library:page',
-  circulation: 'library:circulation',
-  review: 'library:review',
-  branchLife: 'library:branch-life',
-  pageLife: 'library:page-life',
-})
+// owlmeans-structure: allow-file the conformance fixtures are one declarative data set together with the plugin that serves it
+import { CodeScope, CodeStyle, IntrinsicStatus, SpecificationFormat, TransitionAction, WorkcardKind, type AnyTypeSchema, type PlanningFacade, type PlanningPlugin, type StatusFlowSchema, type TransitionReceipt, type Workcard } from '@owlmeans/planning'
+import { BOOK_TYPE, LIBRARY, PERIODICAL_TYPE } from './consts.js'
 
 const flows: StatusFlowSchema[] = [
   {
@@ -64,33 +44,6 @@ const flows: StatusFlowSchema[] = [
   },
 ]
 
-export const BOOK_TYPE: WorkcardTypeSchema = {
-  type: LIBRARY.book,
-  kind: WorkcardKind.Card,
-  version: 1,
-  fields: {
-    type: 'object',
-    properties: { genre: { type: 'string', enum: ['poetry', 'history', 'fiction'] }, signed: { type: 'boolean' } },
-    additionalProperties: false,
-  },
-  flows: [LIBRARY.circulation, LIBRARY.review],
-  specifications: [{ category: 'summary', format: SpecificationFormat.Json, revisioned: true, keepRevisions: 3 }],
-  relationships: [{ name: 'sequel-of', to: [LIBRARY.book], single: true }, { name: 'shelved-near' }],
-  labels: ['rare', 'new', 'signed'],
-  code: { prefix: 'B-', style: CodeStyle.Random, length: 5, uppercase: true, uniqueWithin: CodeScope.Parent },
-}
-
-export const PERIODICAL_TYPE: WorkcardTypeSchema = {
-  type: LIBRARY.periodical,
-  kind: WorkcardKind.Card,
-  version: 1,
-  overridable: true,
-  label: 'Periodical',
-  fields: { type: 'object', additionalProperties: true },
-  flows: [LIBRARY.circulation],
-  specifications: [],
-}
-
 const types: AnyTypeSchema[] = [
   {
     type: LIBRARY.branch,

package/src/conformance/index.ts

@@ -6,4 +6,6 @@
  */
 export * from './assert.js'
 export * from './cases.js'
+export type * from './types.js'
 export * from './fixtures.js'
+export * from './consts.js'

package/src/conformance/types.ts

@@ -0,0 +1,20 @@
+import type { PlanningFacade, PlanningService, PlanningStore } from '@owlmeans/planning'
+
+/** What a case runs against: a planning service over the store under test. */
+export interface ConformanceSubject {
+  /** A service with `planningConformancePlugin` registered and a strictly increasing clock. */
+  service: PlanningService
+  /** The store under test — the service's default store. */
+  store: PlanningStore
+  /** A facade of one organization, acting as a signed-in person. */
+  facade: (entityId: string) => PlanningFacade
+}
+
+/** A capability a store may implement; a case that needs one is skipped for a store without it. */
+export type ConformanceCapability = 'schemas'
+
+export interface ConformanceCase {
+  name: string
+  needs?: ConformanceCapability[]
+  run: (subject: ConformanceSubject) => Promise<void>
+}

package/src/definitions.ts

@@ -1,37 +1,11 @@
-import {
-  assertFlowSchema, assertOverridable, assertTypeSchema, flowInUse, isProject, PlanningSchemaKind,
-  PlanningUnsupported, resolveScopedBundle, SchemaConflict, SchemaInUse, scopedRegistryOf,
-  UnknownStatusFlow, UnknownWorkcardType, WorkcardNotFound,
-} from '@owlmeans/planning'
-import type {
-  PlanningDefinitions, PlanningFacade, PlanningSchemaRegistry, SchemaDeclarations, SchemaStore,
-  SchemaWriteOptions, ScopedSchemaRecord, ScopedSchemaRegistry, StatusFlowSchema, TransitionExecution,
-  Unsubscribe, WorkcardTypeSchema,
-} from '@owlmeans/planning'
+import { assertFlowSchema, assertOverridable, assertTypeSchema, flowInUse, isProject, PlanningSchemaKind, PlanningUnsupported, resolveScopedBundle, SchemaConflict, SchemaInUse, scopedRegistryOf, UnknownStatusFlow, UnknownWorkcardType, WorkcardNotFound, type PlanningDefinitions, type PlanningFacade, type PlanningSchemaRegistry, type SchemaDeclarations, type SchemaStore, type SchemaWriteOptions, type ScopedSchemaRecord, type ScopedSchemaRegistry, type StatusFlowSchema, type TransitionExecution, type Unsubscribe, type WorkcardTypeSchema } from '@owlmeans/planning'
 import { DEFAULT_SCHEMA_VIEWS } from './consts.js'
 import { actorOf } from './executor/changes.js'
-import type { PlanningRuntime } from './service.js'
+import type { PlanningRuntime, SchemaViews, SchemaViewsOptions } from './types.js'
+import type { Planned } from './types.local.js'
 
 const isoNow = (): string => new Date().toISOString()
 
-export interface SchemaViewsOptions {
-  /** The code registry every layer starts from. */
-  code: () => PlanningSchemaRegistry
-  /** Bumps whenever the code registry changes (a plugin's `use`). */
-  version: () => number
-  /** The schema port, when the store has one. */
-  port: () => SchemaStore | undefined
-  /** How many resolved layers are kept. */
-  limit?: number
-}
-
-export interface SchemaViews {
-  /** The code registry itself without a port; the resolved layer with one. */
-  of: (entityId: string, project?: string) => Promise<PlanningSchemaRegistry>
-  /** @throws {PlanningUnsupported} without a port */
-  scoped: (entityId: string, project?: string) => Promise<ScopedSchemaRegistry>
-}
-
 /**
  * The resolved layers of one planning service, cached per (organization, project) and keyed by the
  * organization's schema revision and the code registry's version — a write anywhere, in any
@@ -98,12 +72,6 @@ export const makeSchemaViews = (opts: SchemaViewsOptions): SchemaViews => {
   }
 }
 
-interface Planned {
-  kind: PlanningSchemaKind
-  key: string
-  definition: WorkcardTypeSchema | StatusFlowSchema
-}
-
 const planOf = (declarations: SchemaDeclarations): Planned[] => [
   ...(declarations.flows ?? []).map(flow => ({ kind: PlanningSchemaKind.Flow, key: flow.id, definition: flow })),
   ...(declarations.types ?? []).map(type => ({ kind: PlanningSchemaKind.Type, key: type.type, definition: type })),

package/src/executor/changes.ts

@@ -1,9 +1,5 @@
-import { CommitState, computeChanges, isEmptyChange, TransitionAction } from '@owlmeans/planning'
-import type {
-  ChangeSet, PlanningSchemaRegistry, PlanningScope, RelationshipDraft, Transition, TransitionActor,
-  TransitionExecution, WorkcardDraft,
-} from '@owlmeans/planning'
-import type { Resolved } from './resolve.js'
+import { CommitState, computeChanges, isEmptyChange, TransitionAction, type ChangeSet, type PlanningSchemaRegistry, type PlanningScope, type RelationshipDraft, type Transition, type TransitionActor, type TransitionExecution, type WorkcardDraft } from '@owlmeans/planning'
+import type { Resolved } from './types.js'
 
 const clean = <T extends object>(record: T): T =>
   Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)) as T

package/src/executor/code.ts

@@ -1,13 +1,7 @@
-import {
-  CODE_MINT_ATTEMPTS, CodeScope, CodeStyle, CodeTaken, mintCode, TransitionAction,
-} from '@owlmeans/planning'
-import type {
-  CodePolicy, PlanningExecContext, PlanningPlugin, PlanningScope, TransitionExecution, WorkcardDraft,
-} from '@owlmeans/planning'
+import { CODE_MINT_ATTEMPTS, CodeScope, CodeStyle, CodeTaken, mintCode, TransitionAction, type CodePolicy, type PlanningExecContext, type PlanningPlugin, type PlanningScope, type TransitionExecution, type WorkcardDraft, type Workcard } from '@owlmeans/planning'
 import type { Criteria } from '@owlmeans/resource'
-import type { Workcard } from '@owlmeans/planning'
-import type { PluginRegistry } from '../registry.js'
-import type { Resolved } from './resolve.js'
+import type { PluginRegistry } from '../types.js'
+import type { Resolved } from './types.js'
 
 /** The criteria a code must be unique within — the policy's scope, `parent` when there is none. */
 const scopeCriteria = (

package/src/executor/consts.local.ts

@@ -0,0 +1,8 @@
+import { TransitionAction } from '@owlmeans/planning'
+
+/** The field a create's draft writes once and nothing moves afterwards. */
+export const CREATOR = 'createdBy'
+
+export const TRIMMED = ['title', 'description', 'code'] as const
+
+export const ACTIONS = new Set<string>(Object.values(TransitionAction))

package/src/executor/creator.ts

@@ -1,11 +1,8 @@
-import { PlanningError, TransitionAction } from '@owlmeans/planning'
-import type { PlanningScope, TransitionExecution } from '@owlmeans/planning'
+import { PlanningError, TransitionAction, type PlanningScope, type TransitionExecution } from '@owlmeans/planning'
+import { CREATOR } from './consts.local.js'
 
 const named = (value?: string | null): value is string => value != null && value !== ''
 
-/** The field a create's draft writes once and nothing moves afterwards. */
-const CREATOR = 'createdBy'
-
 /**
  * The subject a create made under `scope` is stamped with as its `createdBy`: the scope's
  * `profileId`, else its `userId`, else the same two of its `actor` — the authenticated subject an

package/src/executor/resolve.ts

@@ -1,35 +1,7 @@
-import {
-  CardTypeNotAllowed, isProject, normalizeParents, ParentNotFound, PlanningError, PlanningSchemaKind,
-  PlanningScopeMismatch, primaryFlowOf, projectOf, SchemaOrigin, slotOf, TransitionAction, UnknownStatusFlow,
-  UnknownWorkcardType, WorkcardKind, WorkcardNotFound,
-} from '@owlmeans/planning'
-import type {
-  AnyTypeSchema, PlanningFacade, PlanningSchemaRegistry, PlanningStore, ProjectTypeSchema,
-  ScopedSchemaRegistry, Specification, SpecificationSlot, StatusFlowSchema, TransitionExecution, Workcard,
-  WorkcardDraft,
-} from '@owlmeans/planning'
-import type { PlanningRuntime } from '../service.js'
-
-/** Everything the steps after resolution read about an execution. */
-export interface Resolved {
-  create: boolean
-  /** The existing card (not a create). */
-  card?: Workcard
-  type: AnyTypeSchema
-  flowId: string
-  flow: StatusFlowSchema
-  /** The primary parent, when it resolves. */
-  parent?: Workcard
-  /** The slot a specification belongs to. */
-  slot?: SpecificationSlot
-  /** The store the type is written to. */
-  store: PlanningStore
-  /**
-   * The registry every later step reads: the service's code registry itself, or — where the store
-   * holds data-defined schemas — the resolved layer of the card's project.
-   */
-  schemas: PlanningSchemaRegistry
-}
+import { CardTypeNotAllowed, isProject, normalizeParents, ParentNotFound, PlanningError, PlanningSchemaKind, PlanningScopeMismatch, primaryFlowOf, projectOf, SchemaOrigin, slotOf, TransitionAction, UnknownStatusFlow, UnknownWorkcardType, WorkcardKind, WorkcardNotFound, type AnyTypeSchema, type PlanningFacade, type PlanningSchemaRegistry, type ProjectTypeSchema, type ScopedSchemaRegistry, type Specification, type TransitionExecution, type Workcard, type WorkcardDraft } from '@owlmeans/planning'
+import type { PlanningRuntime } from '../types.js'
+import { TRIMMED } from './consts.local.js'
+import type { Resolved } from './types.js'
 
 const isScoped = (schemas: PlanningSchemaRegistry): schemas is ScopedSchemaRegistry =>
   typeof (schemas as Partial<ScopedSchemaRegistry>).originOf === 'function'
@@ -45,8 +17,6 @@ const dataDefined = (schemas: PlanningSchemaRegistry | undefined, type: string):
 
 const trimmed = (value: unknown): unknown => typeof value === 'string' ? value.trim() : value
 
-const TRIMMED = ['title', 'description', 'code'] as const
-
 const trim = <T extends object>(record: T | undefined): T | undefined => {
   if (record == null) {
     return record
@@ -64,7 +34,7 @@ const trim = <T extends object>(record: T | undefined): T | undefined => {
  * Step 1: a deep copy with trimmed text, `parents ∋ parent` on a draft, and no duplicate `unset`
  * paths. The caller's object is never touched.
  */
-export const normalizeExecution = (input: TransitionExecution): TransitionExecution => {
+const normalizeExecution = (input: TransitionExecution): TransitionExecution => {
   const exec = structuredClone(input) as TransitionExecution
   if (exec.card != null && typeof exec.card === 'object') {
     const draft = trim(exec.card) as WorkcardDraft
@@ -87,7 +57,7 @@ export const normalizeExecution = (input: TransitionExecution): TransitionExecut
  *
  * @throws {CardTypeNotAllowed}
  */
-export const assertChildAllowed = (
+const assertChildAllowed = (
   runtime: PlanningRuntime, parent: Workcard, kind: WorkcardKind, type: string, view?: PlanningSchemaRegistry
 ): void => {
   if (kind === WorkcardKind.Specification) {
@@ -108,7 +78,7 @@ export const assertChildAllowed = (
 }
 
 /** The layer a parent project admits data-defined children through — `undefined` without a schema port. */
-export const childViewOf = async (
+const childViewOf = async (
   runtime: PlanningRuntime, entityId: string, parent: Workcard
 ): Promise<PlanningSchemaRegistry | undefined> =>
   runtime.schemaStore() == null || !isProject(parent) ? undefined : await runtime.schemasFor(entityId, parent.id)
@@ -119,7 +89,7 @@ export const childViewOf = async (
  * @throws {WorkcardNotFound | PlanningScopeMismatch | UnknownWorkcardType | UnknownStatusFlow}
  * @throws {ParentNotFound | CardTypeNotAllowed | PlanningError}
  */
-export const resolveExecution = async (
+const resolveExecution = async (
   runtime: PlanningRuntime, facade: PlanningFacade, exec: TransitionExecution
 ): Promise<Resolved> => {
   const service = runtime.service()
@@ -232,7 +202,7 @@ export const resolveExecution = async (
 }
 
 /** The project a transition is filed under: a project's own id, else its parent's project. */
-export const projectFor = (resolved: Resolved, exec: TransitionExecution, cardId: string): string | undefined => {
+const projectFor = (resolved: Resolved, exec: TransitionExecution, cardId: string): string | undefined => {
   if (resolved.card != null) {
     return isProject(resolved.card) ? resolved.card.id : projectOf(resolved.card, resolved.parent)
   }
@@ -242,3 +212,7 @@ export const projectFor = (resolved: Resolved, exec: TransitionExecution, cardId
   }
   return projectOf({ kind: draft.kind, parent: draft.parent, parents: draft.parents ?? [] } as unknown as Workcard, resolved.parent)
 }
+
+export const createResolveHelper = () => ({ normalizeExecution, assertChildAllowed, childViewOf, resolveExecution, projectFor })
+
+export const resolveHelper = createResolveHelper()

package/src/executor/types.ts

@@ -0,0 +1,25 @@
+import type { AnyTypeSchema, PlanningSchemaRegistry, PlanningStore, SpecificationSlot, StatusFlowSchema, Workcard } from '@owlmeans/planning'
+import type { createResolveHelper } from './resolve.js'
+
+/** Everything the steps after resolution read about an execution. */
+export interface Resolved {
+  create: boolean
+  /** The existing card (not a create). */
+  card?: Workcard
+  type: AnyTypeSchema
+  flowId: string
+  flow: StatusFlowSchema
+  /** The primary parent, when it resolves. */
+  parent?: Workcard
+  /** The slot a specification belongs to. */
+  slot?: SpecificationSlot
+  /** The store the type is written to. */
+  store: PlanningStore
+  /**
+   * The registry every later step reads: the service's code registry itself, or — where the store
+   * holds data-defined schemas — the resolved layer of the card's project.
+   */
+  schemas: PlanningSchemaRegistry
+}
+
+export type ResolveHelper = ReturnType<typeof createResolveHelper>

package/src/executor/validate.ts

@@ -1,18 +1,9 @@
-import {
-  applyUnset, assertMutable, BODY_MAX, CODE_MAX, DESCRIPTION_MAX, IllegalTransition,
-  LabelNotAllowed, MAX_LABELS, MAX_PARENTS, mergeFields, normalizeParents, ParentNotFound, PlanningError,
-  RelationshipRefused, ruleOf, SpecificationRevisionConflict, SpecificationSlotUnknown, slotOf, TITLE_MAX,
-  TransitionAction, validateFields, validateSpecificationBody, WorkcardKind,
-} from '@owlmeans/planning'
-import type {
-  PlanningFacade, RelationshipDraft, Specification, TransitionExecution, WorkcardDraft,
-} from '@owlmeans/planning'
-import type { PlanningRuntime } from '../service.js'
+import { applyUnset, assertMutable, BODY_MAX, CODE_MAX, DESCRIPTION_MAX, IllegalTransition, LabelNotAllowed, MAX_LABELS, MAX_PARENTS, mergeFields, normalizeParents, ParentNotFound, PlanningError, RelationshipRefused, ruleOf, SpecificationRevisionConflict, SpecificationSlotUnknown, slotOf, TITLE_MAX, TransitionAction, validateFields, validateSpecificationBody, WorkcardKind, type PlanningFacade, type RelationshipDraft, type Specification, type TransitionExecution, type WorkcardDraft } from '@owlmeans/planning'
+import type { PlanningRuntime } from '../types.js'
 import { assertCreatorFixed } from './creator.js'
-import { assertChildAllowed, childViewOf } from './resolve.js'
-import type { Resolved } from './resolve.js'
-
-const ACTIONS = new Set<string>(Object.values(TransitionAction))
+import type { Resolved } from './types.js'
+import { ACTIONS } from './consts.local.js'
+import { resolveHelper } from './resolve.js'
 
 const malformed = (what: string): PlanningError => new PlanningError(`malformed:${what}`)
 
@@ -128,8 +119,8 @@ const assertParentMove = async (
     if (found == null) {
       throw new ParentNotFound(id)
     }
-    assertChildAllowed(
-      runtime, found, resolved.card!.kind, resolved.card!.type, await childViewOf(runtime, facade.scope.entityId, found)
+    resolveHelper.assertChildAllowed(
+      runtime, found, resolved.card!.kind, resolved.card!.type, await resolveHelper.childViewOf(runtime, facade.scope.entityId, found)
     )
   }
 }

package/src/executor.ts

@@ -1,18 +1,14 @@
 import { uuid } from '@owlmeans/basic-ids'
 import type { BasicConfig, BasicContext } from '@owlmeans/context'
-import { PlanningError, PlanningUnsupported, WorkcardConflict } from '@owlmeans/planning'
-import type {
-  ExecuteOptions, PlanningExecContext, PlanningFacade, PlanningPlugin, PlanningStore, Transition,
-  TransitionExecution, TransitionReceipt,
-} from '@owlmeans/planning'
+import { PlanningError, PlanningUnsupported, WorkcardConflict, type ExecuteOptions, type PlanningExecContext, type PlanningFacade, type PlanningPlugin, type PlanningStore, type Transition, type TransitionExecution, type TransitionReceipt } from '@owlmeans/planning'
 import { changeSetOf, transitionOf } from './executor/changes.js'
 import { assignCode } from './executor/code.js'
 import { withCreator } from './executor/creator.js'
 import { makeReceipt } from './executor/receipt.js'
-import { normalizeExecution, projectFor, resolveExecution } from './executor/resolve.js'
-import type { Resolved } from './executor/resolve.js'
+import type { Resolved } from './executor/types.js'
 import { validateExecution } from './executor/validate.js'
-import type { PlanningRuntime } from './service.js'
+import type { PlanningRuntime } from './types.js'
+import { resolveHelper } from './executor/resolve.js'
 
 export { assertCreatorFixed, creatorOf, withCreator } from './executor/creator.js'
 
@@ -83,7 +79,7 @@ export const executeTransition = async (
   const scope = facade.scope
   const at = (runtime.options.now ?? isoNow)()
 
-  let exec = withCreator(normalizeExecution(input), scope)
+  let exec = withCreator(resolveHelper.normalizeExecution(input), scope)
 
   if (scope.entityId == null || scope.entityId === '') {
     throw new PlanningError('malformed:scope-without-entity')
@@ -96,12 +92,12 @@ export const executeTransition = async (
     }
   }
 
-  let resolved = await resolveExecution(runtime, facade, exec)
+  let resolved = await resolveHelper.resolveExecution(runtime, facade, exec)
 
   const before = identityOf(exec)
-  exec = normalizeExecution(await runtime.registry.before(exec, execContextOf(runtime, facade, resolved)))
+  exec = resolveHelper.normalizeExecution(await runtime.registry.before(exec, execContextOf(runtime, facade, resolved)))
   if (identityOf(exec) !== before) {
-    resolved = await resolveExecution(runtime, facade, exec)
+    resolved = await resolveHelper.resolveExecution(runtime, facade, exec)
   }
 
   await validateExecution(runtime, facade, exec, resolved)
@@ -130,7 +126,7 @@ export const executeTransition = async (
 
   const transition = transitionOf({
     exec, resolved, scope, set, cardId, seq, at,
-    project: projectFor(resolved, exec, cardId),
+    project: resolveHelper.projectFor(resolved, exec, cardId),
   })
 
   let appended: Transition

package/src/facade.ts

@@ -1,15 +1,8 @@
-import {
-  criteriaOf, currentSpecification, isProject, isSpecification, linkWhereOf, listOptionsOf, modelOf, projectOf,
-  PlanningUnsupported, specCriteriaOf, transitionWhereOf, WorkcardKind, WorkcardNotFound,
-} from '@owlmeans/planning'
-import type {
-  CommitEvent, CommitSource, PlanningFacade, PlanningScope, Relationship, Specification, Transition,
-  Workcard, WorkcardModel, WorkcardQuery,
-} 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'
 

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
+}