@dotbep/core 0.2.7 → 0.2.8

package/src/entities/bimUses.ts

@@ -1,50 +0,0 @@
-import type { BEP, BIMUse, Milestone, Objective } from '../types/schema.js'
-import { Entity } from '../base/entity.js'
-import { BIMUseSchema } from '../types/schema.js'
-import type { BIMUseResolved, MilestoneResolved, WorkflowResolved } from '../types/resolved.js'
-import type { Workflows } from './workflows.js'
-
-export class BIMUses extends Entity<BIMUse, true> {
-  constructor(getBep: () => BEP, private readonly getWorkflows: () => Workflows) {
-    super(
-      () => getBep().bimUses,
-      getBep,
-      {
-        key: 'bimUses',
-        schema: BIMUseSchema,
-        autoId: true,
-        validate: (item, bep) => {
-          const errors: string[] = []
-          for (const id of item.objectiveIds ?? []) {
-            if (!bep.objectives.some(o => o.id === id))
-              errors.push(`objectives["${id}"] not found`)
-          }
-          for (const id of item.milestoneIds ?? []) {
-            if (!bep.milestones.some(m => m.id === id))
-              errors.push(`milestones["${id}"] not found`)
-          }
-          for (const id of item.workflowIds ?? []) {
-            if (!bep.workflows.some(w => w.id === id))
-              errors.push(`workflows["${id}"] not found`)
-          }
-          return errors
-        },
-      },
-    )
-  }
-
-  listResolved(): BIMUseResolved[] {
-    const bep = this.getBep()
-    const workflowMap = new Map(this.getWorkflows().listResolved().map(w => [w.id, w]))
-    return bep.bimUses.map(bu => ({
-      ...bu,
-      objectives: (bu.objectiveIds ?? []).map(id => bep.objectives.find(o => o.id === id)).filter(Boolean) as Objective[],
-      milestones: (bu.milestoneIds ?? []).map(id => {
-        const m = bep.milestones.find(m => m.id === id)
-        if (!m) return null
-        return { ...m, phase: bep.phases.find(p => p.id === m.phaseId) ?? null } satisfies MilestoneResolved
-      }).filter(Boolean) as MilestoneResolved[],
-      workflows: (bu.workflowIds ?? []).map(id => workflowMap.get(id)).filter(Boolean) as WorkflowResolved[],
-    }))
-  }
-}

package/src/entities/deliverables.ts

@@ -1,66 +0,0 @@
-import type { BEP, Deliverable, Discipline, Extension } from '../types/schema.js'
-import { Entity } from '../base/entity.js'
-import { DeliverableSchema } from '../types/schema.js'
-import type { DeliverableResolved, AssetTypeResolved, LBSNodeResolved, TeamResolved } from '../types/resolved.js'
-import { buildCodeMap } from '../utils/nomenclature.js'
-import type { AssetTypes } from './assetTypes.js'
-import type { LBSNodes } from './lbsNodes.js'
-import type { Milestones } from './milestones.js'
-import type { Teams } from './teams.js'
-
-export class Deliverables extends Entity<Deliverable, true> {
-  constructor(
-    getBep: () => BEP,
-    private readonly getTeams: () => Teams,
-    private readonly getAssetTypes: () => AssetTypes,
-    private readonly getLBSNodes: () => LBSNodes,
-    private readonly getMilestones: () => Milestones,
-  ) {
-    super(
-      () => getBep().deliverables,
-      getBep,
-      {
-        key: 'deliverables',
-        schema: DeliverableSchema,
-        autoId: true,
-      },
-    )
-  }
-
-  listResolved(): DeliverableResolved[] {
-    const bep = this.getBep()
-    const codeMap      = buildCodeMap(bep.deliverables, bep.project.code, bep.lbs)
-    const teamMap      = new Map(this.getTeams().listResolved().map(t => [t.id, t]))
-    const assetTypeMap = new Map(this.getAssetTypes().listResolved().map(dt => [dt.id, dt]))
-    const lbsNodeMap   = new Map(this.getLBSNodes().listResolved().map(n => [n.id, n]))
-    const milestoneMap = new Map(this.getMilestones().listResolved().map(m => [m.id, m]))
-
-    // First pass: resolve everything except predecessor
-    const partials = new Map<string, DeliverableResolved>()
-    for (const d of bep.deliverables) {
-      const milestone = milestoneMap.get(d.milestoneId) ?? null
-      partials.set(d.id, {
-        ...d,
-        nomenclatureCode: codeMap.get(d.id) ?? '',
-        effectiveDate: d.dueDate ?? milestone?.date ?? '',
-        lbsNode:   d.lbsNodeId ? (lbsNodeMap.get(d.lbsNodeId) ?? null) : null as LBSNodeResolved | null,
-        discipline: bep.disciplines.find(di => di.id === d.disciplineId) ?? null as Discipline | null,
-        assetType:  assetTypeMap.get(d.assetTypeId) ?? null as AssetTypeResolved | null,
-        extensions: (d.extensionIds ?? []).map(id => bep.extensions.find(e => e.id === id)).filter(Boolean) as Extension[],
-        responsible: teamMap.get(d.responsibleId) ?? null as TeamResolved | null,
-        milestone:   milestone,
-        predecessor: null,
-      })
-    }
-
-    // Second pass: resolve predecessors using the already-computed partials
-    for (const d of bep.deliverables) {
-      if (d.predecessorId) {
-        const resolved = partials.get(d.id)!
-        resolved.predecessor = partials.get(d.predecessorId) ?? null
-      }
-    }
-
-    return [...partials.values()]
-  }
-}

package/src/entities/disciplines.ts

@@ -1,21 +0,0 @@
-import type { BEP, Discipline } from '../types/schema.js'
-import { Entity } from '../base/entity.js'
-import { DisciplineSchema } from '../types/schema.js'
-import { validateTokenValue } from '../utils/naming.js'
-
-export class Disciplines extends Entity<Discipline> {
-  constructor(getBep: () => BEP) {
-    super(
-      () => getBep().disciplines,
-      getBep,
-      {
-        key: 'disciplines',
-        schema: DisciplineSchema,
-        validate: (d, bep) => {
-          const err = validateTokenValue('discipline', d.id, bep.deliverableNamingConvention)
-          return err ? [err] : []
-        },
-      },
-    )
-  }
-}

package/src/entities/effects.ts

@@ -1,28 +0,0 @@
-import type { BEP, FlowEffect } from '../types/schema.js'
-import { Entity } from '../base/entity.js'
-import { FlowEffectSchema } from '../types/schema.js'
-
-export class Effects extends Entity<FlowEffect> {
-  constructor(getBep: () => BEP) {
-    super(
-      () => getBep().effects,
-      getBep,
-      {
-        key: 'effects',
-        schema: FlowEffectSchema,
-        beforeRemove: (id, bep) => {
-          for (const wf of bep.workflows) {
-            for (const [nodeKey, node] of Object.entries(wf.diagram.nodes)) {
-              if ((node.type === 'process' || node.type === 'automation') && node.timeouts?.some(t => t.effectId === id))
-                throw new Error(`Referenced by: workflows["${wf.id}"].diagram.nodes["${nodeKey}"].timeouts[].effectId`)
-            }
-            for (const [edgeKey, edge] of Object.entries(wf.diagram.edges)) {
-              if (edge.effectIds?.includes(id))
-                throw new Error(`Referenced by: workflows["${wf.id}"].diagram.edges["${edgeKey}"].effectIds`)
-            }
-          }
-        },
-      },
-    )
-  }
-}

package/src/entities/env.ts

@@ -1,17 +0,0 @@
-import type { BEP, EnvVar } from '../types/schema.js'
-import { Entity } from '../base/entity.js'
-import { EnvVarSchema } from '../types/schema.js'
-
-export class Env extends Entity<EnvVar> {
-  constructor(getBep: () => BEP) {
-    super(
-      () => getBep().env,
-      getBep,
-      {
-        key: 'env',
-        idField: 'key',
-        schema: EnvVarSchema,
-      },
-    )
-  }
-}

package/src/entities/events.ts

@@ -1,24 +0,0 @@
-import type { BEP, FlowEvent } from '../types/schema.js'
-import { Entity } from '../base/entity.js'
-import { FlowEventSchema } from '../types/schema.js'
-
-export class Events extends Entity<FlowEvent> {
-  constructor(getBep: () => BEP) {
-    super(
-      () => getBep().events,
-      getBep,
-      {
-        key: 'events',
-        schema: FlowEventSchema,
-        beforeRemove: (id, bep) => {
-          for (const wf of bep.workflows) {
-            for (const [edgeKey, edge] of Object.entries(wf.diagram.edges)) {
-              if ('triggerEventId' in edge && edge.triggerEventId === id)
-                throw new Error(`Referenced by: workflows["${wf.id}"].diagram.edges["${edgeKey}"].trigger`)
-            }
-          }
-        },
-      },
-    )
-  }
-}

package/src/entities/extensions.ts

@@ -1,16 +0,0 @@
-import type { BEP, Extension } from '../types/schema.js'
-import { Entity } from '../base/entity.js'
-import { ExtensionSchema } from '../types/schema.js'
-
-export class Extensions extends Entity<Extension> {
-  constructor(getBep: () => BEP) {
-    super(
-      () => getBep().extensions,
-      getBep,
-      {
-        key: 'extensions',
-        schema: ExtensionSchema,
-      },
-    )
-  }
-}

package/src/entities/flags.ts

@@ -1,17 +0,0 @@
-import type { BEP, Flag } from '../types/schema.js'
-import { Entity } from '../base/entity.js'
-import { FlagSchema } from '../types/schema.js'
-
-export class Flags extends Entity<Flag, true> {
-  constructor(getBep: () => BEP) {
-    super(
-      () => getBep().flags,
-      getBep,
-      {
-        key: 'flags',
-        schema: FlagSchema,
-        autoId: true,
-      },
-    )
-  }
-}

package/src/entities/guides.ts

@@ -1,26 +0,0 @@
-import type { Annex, BEP, Guide } from '../types/schema.js'
-import { Entity } from '../base/entity.js'
-import { GuideSchema } from '../types/schema.js'
-import type { GuideResolved } from '../types/resolved.js'
-
-export class Guides extends Entity<Guide, true> {
-  constructor(getBep: () => BEP) {
-    super(
-      () => getBep().guides,
-      getBep,
-      {
-        key: 'guides',
-        schema: GuideSchema,
-        autoId: true,
-      },
-    )
-  }
-
-  listResolved(): GuideResolved[] {
-    const bep = this.getBep()
-    return bep.guides.map(g => ({
-      ...g,
-      annexes: (g.annexIds ?? []).map(id => bep.annexes.find(a => a.id === id)).filter(Boolean) as Annex[],
-    }))
-  }
-}

package/src/entities/index.ts

@@ -1,32 +0,0 @@
-export { Actions } from './actions.js'
-export { Adapters } from './adapters.js'
-export { Automations } from './automations.js'
-export { Env } from './env.js'
-export { Effects } from './effects.js'
-export { Events } from './events.js'
-export { Annexes } from './annexes.js'
-export { BIMUses } from './bimUses.js'
-export { Deliverables } from './deliverables.js'
-export { Disciplines } from './disciplines.js'
-export { AssetTypes } from './assetTypes.js'
-export { Extensions } from './extensions.js'
-export { Flags } from './flags.js'
-export { Roles } from './roles.js'
-export { Guides } from './guides.js'
-export { LBSNodes } from './lbsNodes.js'
-export type { LBSNodeAddInput, LBSNodeUpdateInput } from './lbsNodes.js'
-export { LODs } from './lods.js'
-export { LOIs } from './lois.js'
-export { LOINEntity } from './loin.js'
-export { Members } from './members.js'
-export { Milestones } from './milestones.js'
-export { Notes } from './notes.js'
-export { Objectives } from './objectives.js'
-export { Phases } from './phases.js'
-export { RemoteDataEntity } from './remoteData.js'
-export { Resolvers } from './resolvers.js'
-export { Softwares } from './softwares.js'
-export { Standards } from './standards.js'
-export type { StandardAddInput } from './standards.js'
-export { Teams } from './teams.js'
-export { Workflows } from './workflows.js'

package/src/entities/lbsNodes.ts

@@ -1,193 +0,0 @@
-import type { BEP, LBSNode } from '../types/schema.js'
-import { Entity } from '../base/entity.js'
-import { LBSNodeSchema } from '../types/schema.js'
-import { buildParentMap, getRootIds, resolveLBSCodes, validateLBS } from '../utils/lbs.js'
-import type { LBSNodeResolved } from '../types/resolved.js'
-import { validateTokenValue } from '../utils/naming.js'
-
-export type LBSNodeAddInput = Omit<LBSNode, 'lbsNodeIds'> & { parentId?: string }
-export type LBSNodeUpdateInput = Partial<Omit<LBSNode, 'lbsNodeIds'>> & { id: string; parentId?: string | null }
-
-export class LBSNodes extends Entity<LBSNode> {
-  constructor(getBep: () => BEP) {
-    super(
-      () => getBep().lbs,
-      getBep,
-      {
-        key: 'lbs',
-        schema: LBSNodeSchema,
-        validate: (item, bep) => {
-          const errors: string[] = []
-
-          const token = item.type === 'zone' ? 'lbsZone' : 'lbsLocation'
-          const tokenErr = validateTokenValue(token, item.id, bep.deliverableNamingConvention)
-          if (tokenErr) errors.push(tokenErr)
-
-          // Per-node check: location nodes cannot have zone children.
-          // Root-must-be-zone and cycle detection are whole-tree invariants
-          // — use validateTree() after building the full structure.
-          if (item.type === 'location' && item.lbsNodeIds?.length) {
-            const nodeMap = new Map(bep.lbs.map(n => [n.id, n]))
-            for (const childId of item.lbsNodeIds ?? []) {
-              if (nodeMap.get(childId)?.type === 'zone')
-                errors.push(`Node "${item.id}" (location) cannot have a zone child ("${childId}").`)
-            }
-          }
-
-          return errors
-        },
-      },
-    )
-  }
-
-  listResolved(): LBSNodeResolved[] {
-    const bep = this.getBep()
-    const parentMap = buildParentMap(bep.lbs)
-    const rootIds = getRootIds(bep.lbs)
-    const nodeMap = new Map(bep.lbs.map(n => [n.id, n]))
-    return bep.lbs.map(node => {
-      const parentId = parentMap.get(node.id)
-      const parentNode = parentId ? nodeMap.get(parentId) : undefined
-      return {
-        ...node,
-        isRoot: rootIds.has(node.id),
-        parent: parentNode ? { id: parentNode.id, name: parentNode.name, type: parentNode.type } : null,
-        children: (node.lbsNodeIds ?? []).map(id => nodeMap.get(id)).filter(Boolean) as LBSNode[],
-      }
-    })
-  }
-
-  addNodes(items: LBSNodeAddInput[]): {
-    succeeded: Array<LBSNode & { parentId: string | null }>
-    failed: Array<{ input: unknown; error: string }>
-  } {
-    const bep = this.getBep()
-    const succeeded: Array<LBSNode & { parentId: string | null }> = []
-    const failed: Array<{ input: unknown; error: string }> = []
-
-    for (const item of items) {
-      if (!item.parentId && item.type !== 'zone') {
-        failed.push({ input: item, error: 'Root nodes (no parentId) must be type "zone".' })
-        continue
-      }
-      if (item.parentId && !bep.lbs.find(n => n.id === item.parentId)) {
-        failed.push({ input: item, error: `No LBS node found with ID "${item.parentId}".` })
-        continue
-      }
-
-      const { parentId, ...node } = item
-      const addResult = this.add([node])
-      if (addResult.failed.length > 0) {
-        failed.push({ input: item, error: addResult.failed[0].error })
-        continue
-      }
-
-      let parent: LBSNode | undefined
-      if (parentId) {
-        parent = bep.lbs.find(n => n.id === parentId)
-        if (parent) {
-          parent.lbsNodeIds ??= []
-          parent.lbsNodeIds.push(item.id)
-        }
-      }
-
-      const errors = this.validateTree()
-      if (errors.length > 0) {
-        bep.lbs.splice(bep.lbs.findIndex(n => n.id === item.id), 1)
-        if (parent?.lbsNodeIds) parent.lbsNodeIds = parent.lbsNodeIds.filter(c => c !== item.id)
-        failed.push({ input: item, error: errors.join('; ') })
-        continue
-      }
-
-      succeeded.push({ ...bep.lbs.find(n => n.id === item.id)!, parentId: parentId ?? null })
-    }
-
-    return { succeeded, failed }
-  }
-
-  updateNodes(items: LBSNodeUpdateInput[]): {
-    succeeded: Array<{
-      id: string
-      before: { name: string; type: string; description: string | undefined; parentId: string | null }
-      after:  { name: string; type: string; description: string | undefined; parentId: string | null }
-    }>
-    failed: Array<{ id: string; error: string }>
-  } {
-    const bep = this.getBep()
-    const succeeded: Array<{
-      id: string
-      before: { name: string; type: string; description: string | undefined; parentId: string | null }
-      after:  { name: string; type: string; description: string | undefined; parentId: string | null }
-    }> = []
-    const failed: Array<{ id: string; error: string }> = []
-
-    for (const item of items) {
-      if (item.parentId && !bep.lbs.find(n => n.id === item.parentId)) {
-        failed.push({ id: item.id, error: `No LBS node found with ID "${item.parentId}".` })
-        continue
-      }
-      if (item.parentId === item.id) {
-        failed.push({ id: item.id, error: 'A node cannot be its own parent.' })
-        continue
-      }
-
-      const beforeNode = bep.lbs.find(n => n.id === item.id)
-      const beforeParentId = buildParentMap(bep.lbs).get(item.id) ?? null
-
-      const { parentId, ...fields } = item
-      const updateResult = this.update([fields])
-      if (updateResult.failed.length > 0) {
-        failed.push({ id: item.id, error: updateResult.failed[0].error })
-        continue
-      }
-
-      const before = { name: beforeNode!.name, type: beforeNode!.type, description: beforeNode!.description, parentId: beforeParentId }
-      const node = bep.lbs.find(n => n.id === item.id)!
-
-      if (parentId !== undefined) {
-        for (const n of bep.lbs) {
-          if (n.lbsNodeIds?.includes(item.id)) n.lbsNodeIds = n.lbsNodeIds.filter(c => c !== item.id)
-        }
-        if (parentId) {
-          const newParent = bep.lbs.find(n => n.id === parentId)!
-          newParent.lbsNodeIds ??= []
-          newParent.lbsNodeIds.push(item.id)
-        }
-      }
-
-      const errors = this.validateTree()
-      if (errors.length > 0) {
-        node.name = before.name
-        node.type = before.type as 'zone' | 'location'
-        if (before.description !== undefined) node.description = before.description
-        else delete node.description
-        if (parentId !== undefined) {
-          for (const n of bep.lbs) {
-            if (n.lbsNodeIds?.includes(item.id)) n.lbsNodeIds = n.lbsNodeIds.filter(c => c !== item.id)
-          }
-          if (before.parentId) {
-            const prevParent = bep.lbs.find(n => n.id === before.parentId)
-            if (prevParent) { prevParent.lbsNodeIds ??= []; prevParent.lbsNodeIds.push(item.id) }
-          }
-        }
-        failed.push({ id: item.id, error: errors.join('; ') })
-        continue
-      }
-
-      const afterParentId = buildParentMap(bep.lbs).get(node.id) ?? null
-      succeeded.push({ id: item.id, before, after: { name: node.name, type: node.type, description: node.description, parentId: afterParentId } })
-    }
-
-    return { succeeded, failed }
-  }
-
-  /** Resolves zone and location codes for nomenclature given a node id. */
-  resolveCodes(nodeId: string | undefined): { zoneCode: string; locationCode: string } {
-    return resolveLBSCodes(nodeId, this.list())
-  }
-
-  /** Validates the full LBS tree and returns a list of structural errors. */
-  validateTree(): string[] {
-    return validateLBS(this.list())
-  }
-}

package/src/entities/lods.ts

@@ -1,22 +0,0 @@
-import type { BEP, LOD } from '../types/schema.js'
-import { Entity } from '../base/entity.js'
-import { LODSchema } from '../types/schema.js'
-
-export class LODs extends Entity<LOD> {
-  constructor(getBep: () => BEP) {
-    super(
-      () => getBep().lods,
-      getBep,
-      {
-        key: 'lods',
-        schema: LODSchema,
-        beforeRemove: (id, bep) => {
-          for (const loin of bep.loin) {
-            const ref = loin.milestones?.find(m => m.lodId === id)
-            if (ref) throw new Error(`Referenced by: loin["${loin.id}"].milestones[lodId=${id}]`)
-          }
-        },
-      },
-    )
-  }
-}

package/src/entities/loin.ts

@@ -1,127 +0,0 @@
-import type { BEP, LOIN, LOINMilestone } from '../types/schema.js'
-import { Entity } from '../base/entity.js'
-import { LOINSchema } from '../types/schema.js'
-import type { LOINResolved } from '../types/resolved.js'
-
-export class LOINEntity extends Entity<LOIN, true> {
-  constructor(getBep: () => BEP) {
-    super(
-      () => getBep().loin,
-      getBep,
-      {
-        key: 'loin',
-        schema: LOINSchema,
-        autoId: true,
-        validate: (item, bep) => {
-          const errors: string[] = []
-          for (const loinMilestone of item.milestones ?? []) {
-            if (!bep.milestones.some(m => m.id === loinMilestone.milestoneId))
-              errors.push(`milestones["${loinMilestone.milestoneId}"] not found`)
-            if (!bep.lods.some(l => l.id === loinMilestone.lodId))
-              errors.push(`lods[${loinMilestone.lodId}] not found`)
-            if (!bep.lois.some(l => l.id === loinMilestone.loiId))
-              errors.push(`lois[${loinMilestone.loiId}] not found`)
-          }
-          return errors
-        },
-      },
-    )
-  }
-
-  addMilestones(items: { loinId: LOIN['id']; milestones: LOINMilestone[] }[]): {
-    succeeded: { loinId: LOIN['id']; element: LOIN['element']; addedMilestones: LOINMilestone['milestoneId'][] }[]
-    failed: { loinId: LOIN['id']; error: string }[]
-  } {
-    const succeeded: { loinId: LOIN['id']; element: LOIN['element']; addedMilestones: LOINMilestone['milestoneId'][] }[] = []
-    const failed: { loinId: LOIN['id']; error: string }[] = []
-
-    for (const item of items) {
-      const loin = this.getBep().loin.find(l => l.id === item.loinId)
-      if (!loin) { failed.push({ loinId: item.loinId, error: `Not found: ${item.loinId}` }); continue }
-
-      const dup = item.milestones.find(m => (loin.milestones ?? []).some(lm => lm.milestoneId === m.milestoneId))
-      if (dup) { failed.push({ loinId: item.loinId, error: `Milestone "${dup.milestoneId}" already exists. Use updateMilestones to modify it.` }); continue }
-
-      const newMilestones = [...(loin.milestones ?? []), ...item.milestones]
-      const result = this.update([{ id: item.loinId, milestones: newMilestones }])
-      if (result.failed.length > 0) { failed.push({ loinId: item.loinId, error: result.failed[0].error }); continue }
-
-      succeeded.push({ loinId: item.loinId, element: loin.element, addedMilestones: item.milestones.map(m => m.milestoneId) })
-    }
-
-    return { succeeded, failed }
-  }
-
-  updateMilestones(items: { loinId: LOIN['id']; milestones: (Partial<LOINMilestone> & { milestoneId: LOINMilestone['milestoneId'] })[] }[]): {
-    succeeded: { loinId: LOIN['id']; element: LOIN['element']; milestones: { milestoneId: LOINMilestone['milestoneId']; before: Omit<LOINMilestone, 'milestoneId'>; after: Omit<LOINMilestone, 'milestoneId'> }[] }[]
-    failed: { loinId: LOIN['id']; error: string }[]
-  } {
-    const succeeded: { loinId: LOIN['id']; element: LOIN['element']; milestones: { milestoneId: LOINMilestone['milestoneId']; before: Omit<LOINMilestone, 'milestoneId'>; after: Omit<LOINMilestone, 'milestoneId'> }[] }[] = []
-    const failed: { loinId: LOIN['id']; error: string }[] = []
-
-    for (const item of items) {
-      const loin = this.getBep().loin.find(l => l.id === item.loinId)
-      if (!loin) { failed.push({ loinId: item.loinId, error: `Not found: ${item.loinId}` }); continue }
-
-      const missing = item.milestones.find(m => !(loin.milestones ?? []).some(lm => lm.milestoneId === m.milestoneId))
-      if (missing) { failed.push({ loinId: item.loinId, error: `Milestone "${missing.milestoneId}" not found. Use addMilestones to create it.` }); continue }
-
-      const befores = new Map(loin.milestones!.map(m => [m.milestoneId, { lodId: m.lodId, loiId: m.loiId, idsPath: m.idsPath }]))
-      const newMilestones: LOINMilestone[] = (loin.milestones ?? []).map(lm => {
-        const patch = item.milestones.find(m => m.milestoneId === lm.milestoneId)
-        return patch ? { ...lm, ...patch } : lm
-      })
-
-      const result = this.update([{ id: item.loinId, milestones: newMilestones }])
-      if (result.failed.length > 0) { failed.push({ loinId: item.loinId, error: result.failed[0].error }); continue }
-
-      const updatedLoin = this.getBep().loin.find(l => l.id === item.loinId)!
-      succeeded.push({
-        loinId: item.loinId,
-        element: loin.element,
-        milestones: item.milestones.map(m => {
-          const after = updatedLoin.milestones!.find(lm => lm.milestoneId === m.milestoneId)!
-          const before = befores.get(m.milestoneId)!
-          return { milestoneId: m.milestoneId, before, after: { lodId: after.lodId, loiId: after.loiId, idsPath: after.idsPath } }
-        }),
-      })
-    }
-
-    return { succeeded, failed }
-  }
-
-  removeMilestones(items: { loinId: LOIN['id']; milestoneIds: LOINMilestone['milestoneId'][] }[]): {
-    succeeded: { loinId: LOIN['id']; element: LOIN['element']; removedMilestones: LOINMilestone['milestoneId'][] }[]
-    failed: { loinId: LOIN['id']; error: string }[]
-  } {
-    const succeeded: { loinId: LOIN['id']; element: LOIN['element']; removedMilestones: LOINMilestone['milestoneId'][] }[] = []
-    const failed: { loinId: LOIN['id']; error: string }[] = []
-
-    for (const item of items) {
-      const loin = this.getBep().loin.find(l => l.id === item.loinId)
-      if (!loin) { failed.push({ loinId: item.loinId, error: `Not found: ${item.loinId}` }); continue }
-
-      const missing = item.milestoneIds.filter(id => !(loin.milestones ?? []).some(m => m.milestoneId === id))
-      if (missing.length > 0) { failed.push({ loinId: item.loinId, error: `Milestones not found in this LOIN: ${missing.join(', ')}` }); continue }
-
-      loin.milestones = (loin.milestones ?? []).filter(m => !item.milestoneIds.includes(m.milestoneId))
-      succeeded.push({ loinId: item.loinId, element: loin.element, removedMilestones: item.milestoneIds })
-    }
-
-    return { succeeded, failed }
-  }
-
-  listResolved(): LOINResolved[] {
-    const bep = this.getBep()
-    return bep.loin.map(l => ({
-      ...l,
-      discipline: bep.disciplines.find(d => d.id === l.disciplineId) ?? null,
-      milestones: (l.milestones ?? []).map(lm => ({
-        ...lm,
-        milestone: bep.milestones.find(m => m.id === lm.milestoneId) ?? null,
-        lod: bep.lods.find(ld => ld.id === lm.lodId) ?? null,
-        loi: bep.lois.find(li => li.id === lm.loiId) ?? null,
-      })),
-    }))
-  }
-}

package/src/entities/lois.ts

@@ -1,22 +0,0 @@
-import type { BEP, LOI } from '../types/schema.js'
-import { Entity } from '../base/entity.js'
-import { LOISchema } from '../types/schema.js'
-
-export class LOIs extends Entity<LOI> {
-  constructor(getBep: () => BEP) {
-    super(
-      () => getBep().lois,
-      getBep,
-      {
-        key: 'lois',
-        schema: LOISchema,
-        beforeRemove: (id, bep) => {
-          for (const loin of bep.loin) {
-            const ref = loin.milestones?.find(m => m.loiId === id)
-            if (ref) throw new Error(`Referenced by: loin["${loin.id}"].milestones[loiId=${id}]`)
-          }
-        },
-      },
-    )
-  }
-}