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

package/src/executor/creator.ts

@@ -0,0 +1,43 @@
+import { PlanningError, TransitionAction, type PlanningScope, type TransitionExecution } from '@owlmeans/planning'
+import { CREATOR } from './consts.local.js'
+import type { CreatorHelper } from './creator/types.js'
+
+const named = (value?: string | null): value is string => value != null && value !== ''
+
+export const createCreatorHelper = (): CreatorHelper => {
+  const creatorOf = (scope: PlanningScope): string | undefined =>
+    [scope.profileId, scope.userId, scope.actor?.profileId, scope.actor?.userId].find(named)
+
+  const withCreator = (exec: TransitionExecution, scope: PlanningScope): TransitionExecution => {
+    if (exec.action !== TransitionAction.Create || exec.card == null || typeof exec.card !== 'object') {
+      return exec
+    }
+    const creator = named(exec.card.createdBy) ? exec.card.createdBy : creatorOf(scope)
+    return { ...exec, card: { ...exec.card,
+      ...(creator != null ? { createdBy: creator } : {}),
+      ...(exec.card.reporter == null && scope.assigneeId != null ? { reporter: scope.assigneeId } : {}),
+      ...(exec.card.assignee == null && scope.defaultAssigneeId != null ? { assignee: scope.defaultAssigneeId } : {}),
+    } }
+  }
+
+  const assertCreatorFixed = (exec: TransitionExecution): void => {
+    if ((exec.changes as Record<string, unknown> | undefined)?.[CREATOR] !== undefined
+      || (exec.unset ?? []).some(path => path.split('.')[0] === CREATOR)) {
+      throw new PlanningError(`immutable:${CREATOR}`)
+    }
+  }
+
+  return { creatorOf, withCreator, assertCreatorFixed }
+}
+
+export const creatorHelper = createCreatorHelper()
+
+/** @deprecated compat:factory-refactor — use `creatorHelper.creatorOf(…)` */
+export const creatorOf = (scope: PlanningScope): string | undefined => creatorHelper.creatorOf(scope)
+
+/** @deprecated compat:factory-refactor — use `creatorHelper.withCreator(…)` */
+export const withCreator = (exec: TransitionExecution, scope: PlanningScope): TransitionExecution =>
+  creatorHelper.withCreator(exec, scope)
+
+/** @deprecated compat:factory-refactor — use `creatorHelper.assertCreatorFixed(…)` */
+export const assertCreatorFixed = (exec: TransitionExecution): void => creatorHelper.assertCreatorFixed(exec)

package/src/executor/resolve/types.ts

@@ -0,0 +1,30 @@
+import type { PlanningFacade, PlanningSchemaRegistry, TransitionExecution, Workcard, WorkcardKind } from '@owlmeans/planning'
+import type { Resolved } from '../types.js'
+
+/** Steps 1 and 4 of the write path, over one service runtime. */
+export interface ResolveUtils {
+  /**
+   * 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.
+   */
+  normalizeExecution: (input: TransitionExecution) => TransitionExecution
+  /**
+   * The parent type's rule for a child of `kind`/`type`: a project lists the `cardTypes` (and
+   * `projectTypes`) it admits, and one declaring `scopedCardTypes` also admits a card type its layer
+   * (`view`, the parent project's resolved schemas) defines as data. Project types are code's alone.
+   *
+   * @throws {CardTypeNotAllowed}
+   */
+  assertChildAllowed: (parent: Workcard, kind: WorkcardKind, type: string, view?: PlanningSchemaRegistry) => void
+  /** The layer a parent project admits data-defined children through — `undefined` without a schema port. */
+  childViewOf: (entityId: string, parent: Workcard) => Promise<PlanningSchemaRegistry | undefined>
+  /**
+   * Step 4: the card, its type and flow, its parent and — for a specification — its slot.
+   *
+   * @throws {WorkcardNotFound | PlanningScopeMismatch | UnknownWorkcardType | UnknownStatusFlow}
+   * @throws {ParentNotFound | CardTypeNotAllowed | PlanningError}
+   */
+  resolveExecution: (facade: PlanningFacade, exec: TransitionExecution) => Promise<Resolved>
+  /** The project a transition is filed under: a project's own id, else its parent's project. */
+  projectFor: (resolved: Resolved, exec: TransitionExecution, cardId: string) => string | undefined
+}

package/src/executor/resolve.ts

@@ -1,33 +1,25 @@
-import {
-  CardTypeNotAllowed, isProject, normalizeParents, ParentNotFound, PlanningError, PlanningScopeMismatch,
-  primaryFlowOf, projectOf, slotOf, TransitionAction, UnknownStatusFlow, WorkcardKind, WorkcardNotFound,
-} from '@owlmeans/planning'
-import type {
-  AnyTypeSchema, PlanningFacade, PlanningStore, ProjectTypeSchema, 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
+import { cardHelper, CardTypeNotAllowed, ParentNotFound, PlanningError, PlanningSchemaKind, PlanningScopeMismatch, SchemaOrigin, specificationHelper, statusHelper, 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 { makePlanningHierarchy } from '../hierarchy.js'
+import { memoHelper } from '@owlmeans/context'
+import type { PlanningRuntime } from '../types.js'
+import { TRIMMED } from './consts.local.js'
+import type { Resolved } from './types.js'
+import type { ResolveUtils } from './resolve/types.js'
+
+const isScoped = (schemas: PlanningSchemaRegistry): schemas is ScopedSchemaRegistry =>
+  typeof (schemas as Partial<ScopedSchemaRegistry>).originOf === 'function'
+
+/** A type the layer resolves from a data-defined record rather than from code. */
+const dataDefined = (schemas: PlanningSchemaRegistry | undefined, type: string): boolean => {
+  if (schemas == null || !isScoped(schemas) || !schemas.has(type)) {
+    return false
+  }
+  const origin = schemas.originOf(PlanningSchemaKind.Type, type)
+  return origin === SchemaOrigin.Entity || origin === SchemaOrigin.Project
 }
 
 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
@@ -41,134 +33,184 @@ const trim = <T extends object>(record: T | undefined): T | undefined => {
   return copy as T
 }
 
-/**
- * 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 exec = structuredClone(input) as TransitionExecution
-  if (exec.card != null && typeof exec.card === 'object') {
-    const draft = trim(exec.card) as WorkcardDraft
-    const parents = normalizeParents(draft.parent, draft.parents)
-    exec.card = { ...draft, ...(parents.length > 0 ? { parents, parent: draft.parent ?? parents[0] } : {}) }
-  }
-  if (exec.changes != null) {
-    exec.changes = trim(exec.changes)
-  }
-  if (exec.unset != null) {
-    exec.unset = [...new Set(exec.unset)]
+export const makeResolveUtils = (runtime: PlanningRuntime): ResolveUtils => {
+  const hierarchy = makePlanningHierarchy(runtime)
+  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
+      const parents = cardHelper.normalizeParents(draft.parent, draft.parents)
+      exec.card = { ...draft, ...(parents.length > 0 ? { parents, parent: draft.parent ?? parents[0] } : {}) }
+    }
+    if (exec.changes != null) {
+      exec.changes = trim(exec.changes)
+    }
+    if (exec.unset != null) {
+      exec.unset = [...new Set(exec.unset)]
+    }
+    return exec
   }
-  return exec
-}
 
-/** The parent type's rule for a child of `kind`/`type`. @throws {CardTypeNotAllowed} */
-export const assertChildAllowed = (
-  runtime: PlanningRuntime, parent: Workcard, kind: WorkcardKind, type: string
-): void => {
-  if (kind === WorkcardKind.Specification) {
-    return
-  }
-  if (!isProject(parent)) {
-    throw new CardTypeNotAllowed(`${parent.type}:${type}`)
-  }
-  const parentType = runtime.service().schemas.type(parent.type) as ProjectTypeSchema
-  const allowed = kind === WorkcardKind.Project ? parentType.projectTypes ?? [] : parentType.cardTypes ?? []
-  if (!allowed.includes(type)) {
+  const assertChildAllowed = (
+    parent: Workcard, kind: WorkcardKind, type: string, view?: PlanningSchemaRegistry
+  ): void => {
+    if (kind === WorkcardKind.Specification) {
+      return
+    }
+    const registry = view ?? runtime.service().schemas
+    const parentType = registry.type(parent.type) as ProjectTypeSchema
+    const childType = registry.has(type) ? registry.type(type) : undefined
+    if (childType?.parents?.types != null && !childType.parents.types.includes(parent.type)) throw new CardTypeNotAllowed(`${type}:parent:${parent.type}`)
+    if (parentType.children != null) {
+      if (!parentType.children.types.includes(type)) throw new CardTypeNotAllowed(`${parent.type}:${type}`)
+      return
+    }
+    if (!cardHelper.isProject(parent)) throw new CardTypeNotAllowed(`${parent.type}:${type}`)
+    const allowed = kind === WorkcardKind.Project ? parentType.projectTypes ?? [] : parentType.cardTypes ?? []
+    if (allowed.includes(type)) {
+      return
+    }
+    if (kind === WorkcardKind.Card && parentType.scopedCardTypes === true && dataDefined(view, type)) {
+      return
+    }
     throw new CardTypeNotAllowed(`${parent.type}:${type}`)
   }
-}
 
-/**
- * Step 4: the card, its type and flow, its parent and — for a specification — its slot.
- *
- * @throws {WorkcardNotFound | PlanningScopeMismatch | UnknownWorkcardType | UnknownStatusFlow}
- * @throws {ParentNotFound | CardTypeNotAllowed | PlanningError}
- */
-export const resolveExecution = async (
-  runtime: PlanningRuntime, facade: PlanningFacade, exec: TransitionExecution
-): Promise<Resolved> => {
-  const service = runtime.service()
-  const schemas = service.schemas
-  const entityId = facade.scope.entityId
-  const create = exec.action === TransitionAction.Create
-
-  let card: Workcard | undefined
-  let type: AnyTypeSchema
-  let parent: Workcard | undefined
-
-  if (create) {
-    if (exec.card == null || typeof exec.card !== 'object') {
-      throw new PlanningError('malformed:create-without-draft')
-    }
-    const draft = exec.card
-    type = schemas.type(draft.type)
-    if (type.kind !== draft.kind) {
-      throw new PlanningError(`malformed:kind:${draft.type}:${draft.kind}`)
-    }
-    // Normalized: the primary parent is first. It must accept the child; so must every project
-    // among the secondary parents.
-    for (const [index, id] of normalizeParents(draft.parent, draft.parents).entries()) {
-      const found = await facade.cards.load(id)
+  const childViewOf = async (
+    entityId: string, parent: Workcard
+  ): Promise<PlanningSchemaRegistry | undefined> =>
+    runtime.schemaStore() == null ? undefined : await runtime.schemasFor(entityId, await hierarchy.project(parent))
+
+  const resolveExecution = async (
+    facade: PlanningFacade, exec: TransitionExecution
+  ): Promise<Resolved> => {
+    const service = runtime.service()
+    const entityId = facade.scope.entityId
+    const create = exec.action === TransitionAction.Create
+    // Without a schema port every step reads the code registry itself, in today's order; with one,
+    // the card's project is found first and the step reads that project's resolved layer.
+    const layered = runtime.schemaStore() != null
+    let schemas: PlanningSchemaRegistry = service.schemas
+
+    let card: Workcard | undefined
+    let type: AnyTypeSchema
+    let parent: Workcard | undefined
+    let project: string | undefined
+
+    if (create) {
+      if (exec.card == null || typeof exec.card !== 'object') {
+        throw new PlanningError('malformed:create-without-draft')
+      }
+      const draft = exec.card
+      const parents = cardHelper.normalizeParents(draft.parent, draft.parents)
+      const loaded = new Map<string, Workcard>()
+      if (layered) {
+        // Loaded through the facade, so a parent this scope cannot see is absent here too.
+        const primary = parents[0] != null ? await facade.cards.load(parents[0]) : null
+        if (parents[0] != null && primary == null) {
+          throw new ParentNotFound(parents[0])
+        }
+        if (primary != null) {
+          loaded.set(parents[0], primary)
+        }
+        const project = draft.kind === WorkcardKind.Project || primary == null
+          ? undefined
+          : await hierarchy.project({ kind: draft.kind, entityId, parent: parents[0], parents } as unknown as Workcard)
+        schemas = await runtime.schemasFor(entityId, project)
+      }
+      type = schemas.type(draft.type)
+      if (type.kind !== draft.kind) {
+        throw new PlanningError(`malformed:kind:${draft.type}:${draft.kind}`)
+      }
+      if (layered && isScoped(schemas) && schemas.isRetired(PlanningSchemaKind.Type, draft.type)) {
+        // Existing cards keep resolving a retired type; nothing new is made of it.
+        throw new UnknownWorkcardType(`retired:${draft.type}`)
+      }
+      // Normalized: the primary parent is first. It must accept the child; so must every project
+      // among the secondary parents.
+      for (const [index, id] of parents.entries()) {
+        const found = loaded.get(id) ?? await facade.cards.load(id)
+        if (found == null) {
+          throw new ParentNotFound(id)
+        }
+        if (index === 0) {
+          parent = found
+        }
+        if (found != null) {
+          const view = !layered ? undefined : index === 0 && cardHelper.isProject(found) ? schemas : await childViewOf(entityId, found)
+          assertChildAllowed(found, draft.kind, draft.type, view)
+        }
+      }
+      if (draft.kind === WorkcardKind.Specification && parent == null) {
+        throw new PlanningError('malformed:specification-without-parent')
+      }
+    } else {
+      if (typeof exec.card !== 'string' || exec.card === '') {
+        throw new PlanningError(`malformed:${exec.action}-without-card`)
+      }
+      const found = await runtime.reader().cards.get(exec.card, entityId)
       if (found == null) {
-        throw new ParentNotFound(id)
+        throw new WorkcardNotFound(exec.card)
       }
-      if (index === 0) {
-        parent = found
+      if (found.entityId !== entityId) {
+        throw new PlanningScopeMismatch(exec.card)
       }
-      if (index === 0 || isProject(found)) {
-        assertChildAllowed(runtime, found, draft.kind, draft.type)
+      if (facade.scope.projects != null && await facade.cards.load(exec.card) == null) {
+        // Outside the scope's projects: absent, exactly like another entity's card.
+        throw new WorkcardNotFound(exec.card)
+      }
+      card = found
+      if (layered) {
+        parent = card.parent != null ? await facade.cards.load(card.parent) ?? undefined : undefined
+        schemas = await runtime.schemasFor(entityId, await hierarchy.project(card))
+        type = schemas.type(card.type)
+      } else {
+        type = schemas.type(card.type)
+        parent = card.parent != null ? await facade.cards.load(card.parent) ?? undefined : undefined
       }
     }
-    if (draft.kind === WorkcardKind.Specification && parent == null) {
-      throw new PlanningError('malformed:specification-without-parent')
-    }
-  } else {
-    if (typeof exec.card !== 'string' || exec.card === '') {
-      throw new PlanningError(`malformed:${exec.action}-without-card`)
-    }
-    const found = await runtime.reader().cards.get(exec.card, entityId)
-    if (found == null) {
-      throw new WorkcardNotFound(exec.card)
+
+    project = card != null ? await hierarchy.project(card)
+      : (exec.card as WorkcardDraft).kind === WorkcardKind.Project ? undefined
+        : await hierarchy.project({ ...(exec.card as WorkcardDraft), entityId } as Workcard)
+    const flowId = exec.flow ?? statusHelper.primaryFlowOf(type)
+    if (!type.flows.includes(flowId)) {
+      throw new UnknownStatusFlow(`${type.type}:${flowId}`)
     }
-    if (found.entityId !== entityId) {
-      throw new PlanningScopeMismatch(exec.card)
+
+    const kind = create ? (exec.card as WorkcardDraft).kind : card!.kind
+    const category = create ? (exec.card as WorkcardDraft).category : (card as Specification | undefined)?.category
+    const slot = kind === WorkcardKind.Specification && parent != null && category != null
+      ? specificationHelper.slotOf(schemas.type(parent.type), category)
+      : undefined
+
+    return {
+      create,
+      project,
+      ...(card != null ? { card } : {}),
+      type,
+      flowId,
+      flow: schemas.flow(flowId),
+      ...(parent != null ? { parent } : {}),
+      ...(slot != null ? { slot } : {}),
+      store: service.store(type.type),
+      schemas,
     }
-    card = found
-    type = schemas.type(card.type)
-    parent = card.parent != null ? await facade.cards.load(card.parent) ?? undefined : undefined
   }
 
-  const flowId = exec.flow ?? primaryFlowOf(type)
-  if (!type.flows.includes(flowId)) {
-    throw new UnknownStatusFlow(`${type.type}:${flowId}`)
+  const projectFor = (resolved: Resolved, exec: TransitionExecution, cardId: string): string | undefined => {
+    if (resolved.card != null) {
+      return cardHelper.isProject(resolved.card) ? resolved.card.id : resolved.project
+    }
+    const draft = exec.card as WorkcardDraft
+    if (draft.kind === WorkcardKind.Project) {
+      return cardId
+    }
+    return resolved.project
   }
 
-  const kind = create ? (exec.card as WorkcardDraft).kind : card!.kind
-  const category = create ? (exec.card as WorkcardDraft).category : (card as Specification | undefined)?.category
-  const slot = kind === WorkcardKind.Specification && parent != null && category != null
-    ? slotOf(schemas.type(parent.type), category)
-    : undefined
-
-  return {
-    create,
-    ...(card != null ? { card } : {}),
-    type,
-    flowId,
-    flow: schemas.flow(flowId),
-    ...(parent != null ? { parent } : {}),
-    ...(slot != null ? { slot } : {}),
-    store: service.store(type.type),
-  }
+  return { normalizeExecution, assertChildAllowed, childViewOf, resolveExecution, projectFor }
 }
 
-/** 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 => {
-  if (resolved.card != null) {
-    return isProject(resolved.card) ? resolved.card.id : projectOf(resolved.card, resolved.parent)
-  }
-  const draft = exec.card as WorkcardDraft
-  if (draft.kind === WorkcardKind.Project) {
-    return cardId
-  }
-  return projectOf({ kind: draft.kind, parent: draft.parent, parents: draft.parents ?? [] } as unknown as Workcard, resolved.parent)
-}
+/** The resolution steps of one service runtime — one per runtime. */
+export const resolveUtilsOf = memoHelper.oncePer(makeResolveUtils)

package/src/executor/types.ts

@@ -0,0 +1,23 @@
+import type { AnyTypeSchema, PlanningSchemaRegistry, PlanningStore, SpecificationSlot, StatusFlowSchema, Workcard } from '@owlmeans/planning'
+
+/** Everything the steps after resolution read about an execution. */
+export interface Resolved {
+  project?: string
+  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
+}

package/src/executor/validate.ts

@@ -1,17 +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 { assertChildAllowed } from './resolve.js'
-import type { Resolved } from './resolve.js'
-
-const ACTIONS = new Set<string>(Object.values(TransitionAction))
+import { BODY_MAX, cardHelper, changesHelper, CODE_MAX, DESCRIPTION_MAX, IllegalTransition, LabelNotAllowed, MAX_LABELS, MAX_PARENTS, ParentNotFound, PlanningError, RelationshipRefused, specificationHelper, SpecificationRevisionConflict, SpecificationSlotUnknown, statusHelper, TITLE_MAX, TransitionAction, validateHelper, WorkcardKind, PlanningResourceKind, type PlanningFacade, type RelationshipDraft, type Specification, type TransitionExecution, type WorkcardDraft } from '@owlmeans/planning'
+import type { PlanningRuntime } from '../types.js'
+import { creatorHelper } from './creator.js'
+import type { Resolved } from './types.js'
+import { ACTIONS } from './consts.local.js'
+import { resolveUtilsOf } from './resolve.js'
 
 const malformed = (what: string): PlanningError => new PlanningError(`malformed:${what}`)
 
@@ -58,10 +50,10 @@ const assertShape = (exec: TransitionExecution, resolved: Resolved): void => {
   assertText('code', changes.code ?? undefined, CODE_MAX, false)
 }
 
-const assertFlow = (exec: TransitionExecution, resolved: Resolved, runtime: PlanningRuntime): void => {
+const assertFlow = (exec: TransitionExecution, resolved: Resolved): void => {
   if (resolved.create) {
     const status = (exec.card as WorkcardDraft).status
-    const primary = runtime.service().schemas.primaryFlow(resolved.type.type)
+    const primary = resolved.schemas.primaryFlow(resolved.type.type)
     if (status != null && !primary.statuses.some(definition => definition.key === status)) {
       throw new IllegalTransition(`${primary.id}:create:${status}`)
     }
@@ -72,24 +64,24 @@ const assertFlow = (exec: TransitionExecution, resolved: Resolved, runtime: Plan
   }
   const card = resolved.card!
   const from = card.flows[resolved.flowId] ?? card.status
-  if (ruleOf(resolved.flow, exec.transition!, from) == null) {
+  if (statusHelper.ruleOf(resolved.flow, exec.transition!, from) == null) {
     throw new IllegalTransition(`${resolved.flowId}:${exec.transition}:${from}`)
   }
 }
 
-const assertFields = (exec: TransitionExecution, resolved: Resolved, runtime: PlanningRuntime): void => {
-  const schemas = runtime.service().schemas
+const assertFields = (exec: TransitionExecution, resolved: Resolved): void => {
+  const schemas = resolved.schemas
   if (resolved.create) {
     const draft = exec.card as WorkcardDraft
-    validateFields(schemas, resolved.type.type, mergeFields(draft.fields, exec.changes?.fields))
+    validateHelper.validateFields(schemas, resolved.type.type, changesHelper.mergeFields(draft.fields, exec.changes?.fields))
     return
   }
   const clears = (exec.unset ?? []).filter(path => path.startsWith('fields.'))
   if (exec.changes?.fields == null && clears.length === 0) {
     return
   }
-  const merged = applyUnset({ fields: mergeFields(resolved.card!.fields, exec.changes?.fields) }, clears)
-  validateFields(schemas, resolved.type.type, merged.fields)
+  const merged = changesHelper.applyUnset({ fields: changesHelper.mergeFields(resolved.card!.fields, exec.changes?.fields) }, clears)
+  validateHelper.validateFields(schemas, resolved.type.type, merged.fields)
 }
 
 const assertLabels = (exec: TransitionExecution, resolved: Resolved): void => {
@@ -117,7 +109,8 @@ const assertParentMove = async (
     return
   }
   const changes = exec.changes ?? {}
-  const moved = [...new Set(normalizeParents(changes.parent, changes.parents))]
+  const resolve = resolveUtilsOf(runtime)
+  const moved = [...new Set(cardHelper.normalizeParents(changes.parent, changes.parents))]
     .filter(id => id !== resolved.card!.parent && !resolved.card!.parents.includes(id))
   for (const id of moved) {
     if (id === resolved.card!.id) {
@@ -127,18 +120,20 @@ const assertParentMove = async (
     if (found == null) {
       throw new ParentNotFound(id)
     }
-    assertChildAllowed(runtime, found, resolved.card!.kind, resolved.card!.type)
+    resolve.assertChildAllowed(
+      found, resolved.card!.kind, resolved.card!.type, await resolve.childViewOf(facade.scope.entityId, found)
+    )
   }
 }
 
 const assertSpecification = async (
-  exec: TransitionExecution, resolved: Resolved, runtime: PlanningRuntime, facade: PlanningFacade
+  exec: TransitionExecution, resolved: Resolved, facade: PlanningFacade
 ): Promise<void> => {
   const kind = resolved.create ? (exec.card as WorkcardDraft).kind : resolved.card!.kind
   if (kind !== WorkcardKind.Specification) {
     return
   }
-  const schemas = runtime.service().schemas
+  const schemas = resolved.schemas
 
   if (resolved.create) {
     const draft = exec.card as WorkcardDraft
@@ -146,7 +141,7 @@ const assertSpecification = async (
     if (draft.category == null || draft.category === '') {
       throw malformed('specification-without-category')
     }
-    const slot = slotOf(schemas.type(parent.type), draft.category)
+    const slot = specificationHelper.slotOf(schemas.type(parent.type), draft.category)
     if (slot == null) {
       throw new SpecificationSlotUnknown(`${parent.type}:${draft.category}`)
     }
@@ -154,7 +149,7 @@ const assertSpecification = async (
       throw malformed(`format:${draft.category}:${draft.format}`)
     }
     assertText('body', draft.body, BODY_MAX, false)
-    validateSpecificationBody(slot, draft.body)
+    validateHelper.validateSpecificationBody(slot, draft.body)
     if (slot.multiple !== true && await facade.specifications.current(parent.id!, draft.category) != null) {
       throw new SpecificationRevisionConflict(`${parent.id}:${draft.category}`)
     }
@@ -175,7 +170,7 @@ const assertSpecification = async (
   }
   if (changes.body != null) {
     assertText('body', changes.body, BODY_MAX, false)
-    validateSpecificationBody(slot, changes.body)
+    validateHelper.validateSpecificationBody(slot, changes.body)
   }
 }
 
@@ -207,15 +202,20 @@ const assertRelationships = async (
       }
       continue
     }
-    const target = await facade.cards.load(draft.to)
+    const kind = rule.toKind ?? PlanningResourceKind.Workcard
+    if (draft.toKind != null && draft.toKind !== kind) throw new RelationshipRefused(`to-kind:${draft.type}`)
+    if (draft.fromKind != null && draft.fromKind !== PlanningResourceKind.Workcard) throw new RelationshipRefused(`from-kind:${draft.type}`)
+    draft.toKind = kind
+    const target = kind === PlanningResourceKind.Assignee ? await facade.assignees.load(draft.to)
+      : kind === PlanningResourceKind.Team ? await facade.teams.load(draft.to) : await facade.cards.load(draft.to)
     if (target == null) {
       throw new RelationshipRefused(`to:${draft.to}`)
     }
     if (rule.from != null && !rule.from.includes(resolved.type.type)) {
       throw new RelationshipRefused(`from-type:${draft.type}:${resolved.type.type}`)
     }
-    if (rule.to != null && !rule.to.includes(target.type)) {
-      throw new RelationshipRefused(`to-type:${draft.type}:${target.type}`)
+    if (rule.to != null && !rule.to.includes('type' in target ? target.type : '')) {
+      throw new RelationshipRefused(`to-type:${draft.type}:${'type' in target ? target.type : kind}`)
     }
     if (rule.single === true) {
       const count = (counted.get(draft.type) ?? 0) + 1
@@ -232,8 +232,9 @@ const assertRelationships = async (
 }
 
 /**
- * Step 6: shape, flow rule, immutables, `fields`, labels, parent moves, the specification slot and
- * relationships — in that order. Nothing is written by a refusal here.
+ * Step 6: shape, flow rule, immutables (`createdBy` among them, `creatorHelper.assertCreatorFixed`),
+ * `fields`, labels, parent moves, the specification slot and relationships — in that order.
+ * Nothing is written by a refusal here.
  *
  * @throws {PlanningError} `malformed:*` / `immutable:*`
  * @throws {IllegalTransition | FieldsInvalid | LabelNotAllowed | ParentNotFound | CardTypeNotAllowed}
@@ -243,11 +244,12 @@ export const validateExecution = async (
   runtime: PlanningRuntime, facade: PlanningFacade, exec: TransitionExecution, resolved: Resolved
 ): Promise<void> => {
   assertShape(exec, resolved)
-  assertFlow(exec, resolved, runtime)
-  assertMutable(exec, resolved.type)
-  assertFields(exec, resolved, runtime)
+  assertFlow(exec, resolved)
+  changesHelper.assertMutable(exec, resolved.type)
+  creatorHelper.assertCreatorFixed(exec)
+  assertFields(exec, resolved)
   assertLabels(exec, resolved)
   await assertParentMove(exec, resolved, runtime, facade)
-  await assertSpecification(exec, resolved, runtime, facade)
+  await assertSpecification(exec, resolved, facade)
   await assertRelationships(exec, resolved, facade)
 }