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

package/src/executor/resolve.ts

@@ -1,7 +1,9 @@
-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 { 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 { 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'
@@ -30,189 +32,173 @@ 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.
- */
-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 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`: 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}
- */
-const assertChildAllowed = (
-  runtime: PlanningRuntime, parent: Workcard, kind: WorkcardKind, type: string, view?: PlanningSchemaRegistry
-): void => {
-  if (kind === WorkcardKind.Specification) {
-    return
-  }
-  if (!isProject(parent)) {
+  const assertChildAllowed = (
+    parent: Workcard, kind: WorkcardKind, type: string, view?: PlanningSchemaRegistry
+  ): void => {
+    if (kind === WorkcardKind.Specification) {
+      return
+    }
+    if (!cardHelper.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)) {
+      return
+    }
+    if (kind === WorkcardKind.Card && parentType.scopedCardTypes === true && dataDefined(view, type)) {
+      return
+    }
     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)) {
-    return
-  }
-  if (kind === WorkcardKind.Card && parentType.scopedCardTypes === true && dataDefined(view, type)) {
-    return
-  }
-  throw new CardTypeNotAllowed(`${parent.type}:${type}`)
-}
 
-/** The layer a parent project admits data-defined children through — `undefined` without a schema port. */
-const childViewOf = async (
-  runtime: PlanningRuntime, entityId: string, parent: Workcard
-): Promise<PlanningSchemaRegistry | undefined> =>
-  runtime.schemaStore() == null || !isProject(parent) ? undefined : await runtime.schemasFor(entityId, parent.id)
-
-/**
- * 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}
- */
-const resolveExecution = async (
-  runtime: PlanningRuntime, 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
-
-  if (create) {
-    if (exec.card == null || typeof exec.card !== 'object') {
-      throw new PlanningError('malformed:create-without-draft')
-    }
-    const draft = exec.card
-    const parents = 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])
+  const childViewOf = async (
+    entityId: string, parent: Workcard
+  ): Promise<PlanningSchemaRegistry | undefined> =>
+    runtime.schemaStore() == null || !cardHelper.isProject(parent) ? undefined : await runtime.schemasFor(entityId, parent.id)
+
+  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
+
+    if (create) {
+      if (exec.card == null || typeof exec.card !== 'object') {
+        throw new PlanningError('malformed:create-without-draft')
       }
-      if (primary != null) {
-        loaded.set(parents[0], primary)
+      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
+          : cardHelper.projectOf({ kind: draft.kind, parent: parents[0], parents } as unknown as Workcard, primary)
+        schemas = await runtime.schemasFor(entityId, project)
       }
-      const project = draft.kind === WorkcardKind.Project || primary == null
-        ? undefined
-        : projectOf({ kind: draft.kind, parent: parents[0], parents } as unknown as Workcard, primary)
-      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)
+      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 (index === 0 || cardHelper.isProject(found)) {
+          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)) {
-        const view = !layered ? undefined : index === 0 && isProject(found) ? schemas : await childViewOf(runtime, entityId, found)
-        assertChildAllowed(runtime, found, draft.kind, draft.type, view)
+      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, cardHelper.projectOf(card, parent))
+        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)
-    }
-    if (found.entityId !== entityId) {
-      throw new PlanningScopeMismatch(exec.card)
-    }
-    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, projectOf(card, parent))
-      type = schemas.type(card.type)
-    } else {
-      type = schemas.type(card.type)
-      parent = card.parent != null ? await facade.cards.load(card.parent) ?? undefined : undefined
+
+    const flowId = exec.flow ?? statusHelper.primaryFlowOf(type)
+    if (!type.flows.includes(flowId)) {
+      throw new UnknownStatusFlow(`${type.type}:${flowId}`)
     }
-  }
 
-  const flowId = exec.flow ?? primaryFlowOf(type)
-  if (!type.flows.includes(flowId)) {
-    throw new UnknownStatusFlow(`${type.type}:${flowId}`)
+    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,
+      ...(card != null ? { card } : {}),
+      type,
+      flowId,
+      flow: schemas.flow(flowId),
+      ...(parent != null ? { parent } : {}),
+      ...(slot != null ? { slot } : {}),
+      store: service.store(type.type),
+      schemas,
+    }
   }
 
-  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),
-    schemas,
+  const projectFor = (resolved: Resolved, exec: TransitionExecution, cardId: string): string | undefined => {
+    if (resolved.card != null) {
+      return cardHelper.isProject(resolved.card) ? resolved.card.id : cardHelper.projectOf(resolved.card, resolved.parent)
+    }
+    const draft = exec.card as WorkcardDraft
+    if (draft.kind === WorkcardKind.Project) {
+      return cardId
+    }
+    return cardHelper.projectOf({ kind: draft.kind, parent: draft.parent, parents: draft.parents ?? [] } as unknown as Workcard, resolved.parent)
   }
-}
 
-/** The project a transition is filed under: a project's own id, else its parent's project. */
-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)
+  return { normalizeExecution, assertChildAllowed, childViewOf, resolveExecution, projectFor }
 }
 
-export const createResolveHelper = () => ({ normalizeExecution, assertChildAllowed, childViewOf, resolveExecution, projectFor })
-
-export const resolveHelper = createResolveHelper()
+/** The resolution steps of one service runtime — one per runtime. */
+export const resolveUtilsOf = memoHelper.oncePer(makeResolveUtils)

package/src/executor/types.ts

@@ -1,5 +1,4 @@
 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 {
@@ -21,5 +20,3 @@ export interface Resolved {
    */
   schemas: PlanningSchemaRegistry
 }
-
-export type ResolveHelper = ReturnType<typeof createResolveHelper>

package/src/executor/validate.ts

@@ -1,9 +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, type PlanningFacade, type RelationshipDraft, type Specification, type TransitionExecution, type WorkcardDraft } from '@owlmeans/planning'
+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, 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 { creatorHelper } from './creator.js'
 import type { Resolved } from './types.js'
 import { ACTIONS } from './consts.local.js'
-import { resolveHelper } from './resolve.js'
+import { resolveUtilsOf } from './resolve.js'
 
 const malformed = (what: string): PlanningError => new PlanningError(`malformed:${what}`)
 
@@ -64,7 +64,7 @@ const assertFlow = (exec: TransitionExecution, resolved: Resolved): void => {
   }
   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}`)
   }
 }
@@ -73,15 +73,15 @@ 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 => {
@@ -109,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) {
@@ -119,8 +120,8 @@ const assertParentMove = async (
     if (found == null) {
       throw new ParentNotFound(id)
     }
-    resolveHelper.assertChildAllowed(
-      runtime, found, resolved.card!.kind, resolved.card!.type, await resolveHelper.childViewOf(runtime, facade.scope.entityId, found)
+    resolve.assertChildAllowed(
+      found, resolved.card!.kind, resolved.card!.type, await resolve.childViewOf(facade.scope.entityId, found)
     )
   }
 }
@@ -140,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}`)
     }
@@ -148,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}`)
     }
@@ -169,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)
   }
 }
 
@@ -226,7 +227,7 @@ const assertRelationships = async (
 }
 
 /**
- * Step 6: shape, flow rule, immutables (`createdBy` among them, {@link assertCreatorFixed}),
+ * 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.
  *
@@ -239,8 +240,8 @@ export const validateExecution = async (
 ): Promise<void> => {
   assertShape(exec, resolved)
   assertFlow(exec, resolved)
-  assertMutable(exec, resolved.type)
-  assertCreatorFixed(exec)
+  changesHelper.assertMutable(exec, resolved.type)
+  creatorHelper.assertCreatorFixed(exec)
   assertFields(exec, resolved)
   assertLabels(exec, resolved)
   await assertParentMove(exec, resolved, runtime, facade)

package/src/executor.ts

@@ -1,16 +1,18 @@
-import { uuid } from '@owlmeans/basic-ids'
+
 import type { BasicConfig, BasicContext } from '@owlmeans/context'
 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 { changesUtils } from './executor/changes.js'
+import { codeUtils } from './executor/code.js'
+import { creatorHelper } from './executor/creator.js'
 import { makeReceipt } from './executor/receipt.js'
 import type { Resolved } from './executor/types.js'
 import { validateExecution } from './executor/validate.js'
 import type { PlanningRuntime } from './types.js'
-import { resolveHelper } from './executor/resolve.js'
+import { resolveUtilsOf } from './executor/resolve.js'
+import { idHelper } from '@owlmeans/basic-ids'
 
-export { assertCreatorFixed, creatorOf, withCreator } from './executor/creator.js'
+export { assertCreatorFixed, createCreatorHelper, creatorHelper, creatorOf, withCreator } from './executor/creator.js'
+export type * from './executor/creator/types.js'
 
 const isoNow = (): string => new Date().toISOString()
 
@@ -63,10 +65,10 @@ const currentReceipt = async (
 /**
  * THE write path. Nothing is appended before step 11, so every refusal leaves the log untouched.
  *
- * 1 normalize (a create's `createdBy` defaults to the scope's subject — {@link withCreator}) →
+ * 1 normalize (a create's `createdBy` defaults to the scope's subject — `creatorHelper.withCreator`) →
  * 2 scope → 3 idempotency (a known `key` answers its first receipt, before any validation) →
  * 4 resolve → 5 the plugins' `before` chain (re-resolved once when it moved the type or the parent)
- * → 6 validate (a `createdBy` in `changes`/`unset` is refused — {@link assertCreatorFixed}) →
+ * → 6 validate (a `createdBy` in `changes`/`unset` is refused — `creatorHelper.assertCreatorFixed`) →
  * 7 allocate the card id → 8 code → 9 changes (an update changing nothing answers
  * the current receipt and appends nothing) → 10 seq, a CAS against the head → 11 append →
  * 12 request the projection → 13 receipt → 14 `wait`.
@@ -78,8 +80,9 @@ export const executeTransition = async (
 ): Promise<TransitionReceipt> => {
   const scope = facade.scope
   const at = (runtime.options.now ?? isoNow)()
+  const resolve = resolveUtilsOf(runtime)
 
-  let exec = withCreator(resolveHelper.normalizeExecution(input), scope)
+  let exec = creatorHelper.withCreator(resolve.normalizeExecution(input), scope)
 
   if (scope.entityId == null || scope.entityId === '') {
     throw new PlanningError('malformed:scope-without-entity')
@@ -92,12 +95,12 @@ export const executeTransition = async (
     }
   }
 
-  let resolved = await resolveHelper.resolveExecution(runtime, facade, exec)
+  let resolved = await resolve.resolveExecution(facade, exec)
 
   const before = identityOf(exec)
-  exec = resolveHelper.normalizeExecution(await runtime.registry.before(exec, execContextOf(runtime, facade, resolved)))
+  exec = resolve.normalizeExecution(await runtime.registry.before(exec, execContextOf(runtime, facade, resolved)))
   if (identityOf(exec) !== before) {
-    resolved = await resolveHelper.resolveExecution(runtime, facade, exec)
+    resolved = await resolve.resolveExecution(facade, exec)
   }
 
   await validateExecution(runtime, facade, exec, resolved)
@@ -109,12 +112,12 @@ export const executeTransition = async (
   }
 
   const cardId = resolved.create
-    ? store.newId?.() ?? runtime.options.ids?.() ?? uuid()
+    ? store.newId?.() ?? runtime.options.ids?.() ?? idHelper.uuid()
     : resolved.card!.id!
 
-  exec = await assignCode(exec, resolved, scope, runtime.registry, execContextOf(runtime, facade, resolved))
+  exec = await codeUtils.assignCode(exec, resolved, scope, runtime.registry, execContextOf(runtime, facade, resolved))
 
-  const { set, empty } = changeSetOf(exec, resolved, resolved.schemas, at)
+  const { set, empty } = changesUtils.changeSetOf(exec, resolved, resolved.schemas, at)
   if (empty) {
     return await currentReceipt(store, resolved, scope.entityId, opts)
   }
@@ -124,9 +127,9 @@ export const executeTransition = async (
     throw new WorkcardConflict(`${cardId}:create:${seq}`)
   }
 
-  const transition = transitionOf({
+  const transition = changesUtils.transitionOf({
     exec, resolved, scope, set, cardId, seq, at,
-    project: resolveHelper.projectFor(resolved, exec, cardId),
+    project: resolve.projectFor(resolved, exec, cardId),
   })
 
   let appended: Transition