@lionweb/class-core 0.8.0-beta.2 → 0.8.0-beta.4

package/src/deltas/serialization/deserializer.g.ts

@@ -42,12 +42,6 @@ import {
     ChildMovedInSameContainmentDelta,
     ChildReplacedDelta,
     CompositeDelta,
-    EntryMovedAndReplacedFromOtherReferenceDelta,
-    EntryMovedAndReplacedFromOtherReferenceInSameParentDelta,
-    EntryMovedAndReplacedInSameReferenceDelta,
-    EntryMovedFromOtherReferenceDelta,
-    EntryMovedFromOtherReferenceInSameParentDelta,
-    EntryMovedInSameReferenceDelta,
     NoOpDelta,
     PartitionAddedDelta,
     PartitionDeletedDelta,
@@ -243,63 +237,6 @@ export const deltaDeserializer = (languageBases: ILanguageBase[], idMapping: IdM
                 const oldTarget = idMapping.fromRefId(delta.oldTarget);
                 return new ReferenceChangedDelta(parent, reference, index, newTarget, oldTarget);
             }
-            case "EntryMovedFromOtherReference": {
-                const oldParent = idMapping.fromId(delta.oldParent);
-                const oldReference = resolvedReferenceFrom(delta.oldReference, oldParent.classifier);
-                const oldIndex = delta.oldIndex;
-                const newParent = idMapping.fromId(delta.newParent);
-                const newReference = resolvedReferenceFrom(delta.newReference, newParent.classifier);
-                const newIndex = delta.newIndex;
-                const movedTarget = idMapping.fromRefId(delta.movedTarget);
-                return new EntryMovedFromOtherReferenceDelta(oldParent, oldReference, oldIndex, newParent, newReference, newIndex, movedTarget);
-            }
-            case "EntryMovedFromOtherReferenceInSameParent": {
-                const parent = idMapping.fromId(delta.parent);
-                const oldReference = resolvedReferenceFrom(delta.oldReference, parent.classifier);
-                const oldIndex = delta.oldIndex;
-                const newReference = resolvedReferenceFrom(delta.newReference, parent.classifier);
-                const newIndex = delta.newIndex;
-                const movedTarget = idMapping.fromRefId(delta.movedTarget);
-                return new EntryMovedFromOtherReferenceInSameParentDelta(parent, oldReference, oldIndex, newReference, newIndex, movedTarget);
-            }
-            case "EntryMovedInSameReference": {
-                const parent = idMapping.fromId(delta.parent);
-                const reference = resolvedReferenceFrom(delta.reference, parent.classifier);
-                const oldIndex = delta.oldIndex;
-                const newIndex = delta.newIndex;
-                const movedTarget = idMapping.fromRefId(delta.movedTarget);
-                return new EntryMovedInSameReferenceDelta(parent, reference, oldIndex, newIndex, movedTarget);
-            }
-            case "EntryMovedAndReplacedFromOtherReference": {
-                const newParent = idMapping.fromId(delta.newParent);
-                const newReference = resolvedReferenceFrom(delta.newReference, newParent.classifier);
-                const newIndex = delta.newIndex;
-                const movedTarget = idMapping.fromRefId(delta.movedTarget);
-                const oldParent = idMapping.fromId(delta.oldParent);
-                const oldReference = resolvedReferenceFrom(delta.oldReference, oldParent.classifier);
-                const oldIndex = delta.oldIndex;
-                const replacedTarget = idMapping.fromRefId(delta.replacedTarget);
-                return new EntryMovedAndReplacedFromOtherReferenceDelta(newParent, newReference, newIndex, movedTarget, oldParent, oldReference, oldIndex, replacedTarget);
-            }
-            case "EntryMovedAndReplacedFromOtherReferenceInSameParent": {
-                const parent = idMapping.fromId(delta.parent);
-                const oldReference = resolvedReferenceFrom(delta.oldReference, parent.classifier);
-                const oldIndex = delta.oldIndex;
-                const newReference = resolvedReferenceFrom(delta.newReference, parent.classifier);
-                const newIndex = delta.newIndex;
-                const movedTarget = idMapping.fromRefId(delta.movedTarget);
-                const replacedTarget = idMapping.fromRefId(delta.replacedTarget);
-                return new EntryMovedAndReplacedFromOtherReferenceInSameParentDelta(parent, oldReference, oldIndex, newReference, newIndex, movedTarget, replacedTarget);
-            }
-            case "EntryMovedAndReplacedInSameReference": {
-                const parent = idMapping.fromId(delta.parent);
-                const reference = resolvedReferenceFrom(delta.reference, parent.classifier);
-                const oldIndex = delta.oldIndex;
-                const newIndex = delta.newIndex;
-                const movedTarget = idMapping.fromRefId(delta.movedTarget);
-                const replacedTarget = idMapping.fromRefId(delta.replacedTarget);
-                return new EntryMovedAndReplacedInSameReferenceDelta(parent, reference, oldIndex, newIndex, movedTarget, replacedTarget);
-            }
             case "Composite": {
                 const parts = delta.parts.map(deserializedDelta);
                 return new CompositeDelta(parts);

package/src/deltas/serialization/serializer.g.ts

@@ -38,12 +38,6 @@ import {
     ChildMovedInSameContainmentDelta,
     ChildReplacedDelta,
     CompositeDelta,
-    EntryMovedAndReplacedFromOtherReferenceDelta,
-    EntryMovedAndReplacedFromOtherReferenceInSameParentDelta,
-    EntryMovedAndReplacedInSameReferenceDelta,
-    EntryMovedFromOtherReferenceDelta,
-    EntryMovedFromOtherReferenceInSameParentDelta,
-    EntryMovedInSameReferenceDelta,
     NoOpDelta,
     PartitionAddedDelta,
     PartitionDeletedDelta,
@@ -72,12 +66,6 @@ import {
     ChildMovedInSameContainmentSerializedDelta,
     ChildReplacedSerializedDelta,
     CompositeSerializedDelta,
-    EntryMovedAndReplacedFromOtherReferenceInSameParentSerializedDelta,
-    EntryMovedAndReplacedFromOtherReferenceSerializedDelta,
-    EntryMovedAndReplacedInSameReferenceSerializedDelta,
-    EntryMovedFromOtherReferenceInSameParentSerializedDelta,
-    EntryMovedFromOtherReferenceSerializedDelta,
-    EntryMovedInSameReferenceSerializedDelta,
     NoOpSerializedDelta,
     PartitionAddedSerializedDelta,
     PartitionDeletedSerializedDelta,
@@ -360,81 +348,6 @@ export const serializeDelta = (delta: IDelta): SerializedDelta => {
         } as ReferenceChangedSerializedDelta;
     }
 
-    if (delta instanceof EntryMovedFromOtherReferenceDelta) {
-        return {
-            kind: "EntryMovedFromOtherReference",
-            oldParent: delta.oldParent.id,
-            oldReference: metaPointerFor(delta.oldReference),
-            oldIndex: delta.oldIndex,
-            newParent: delta.newParent.id,
-            newReference: metaPointerFor(delta.newReference),
-            newIndex: delta.newIndex,
-            movedTarget: idFrom(delta.movedTarget)
-        } as EntryMovedFromOtherReferenceSerializedDelta;
-    }
-
-    if (delta instanceof EntryMovedFromOtherReferenceInSameParentDelta) {
-        return {
-            kind: "EntryMovedFromOtherReferenceInSameParent",
-            parent: delta.parent.id,
-            oldReference: metaPointerFor(delta.oldReference),
-            oldIndex: delta.oldIndex,
-            newReference: metaPointerFor(delta.newReference),
-            newIndex: delta.newIndex,
-            movedTarget: idFrom(delta.movedTarget)
-        } as EntryMovedFromOtherReferenceInSameParentSerializedDelta;
-    }
-
-    if (delta instanceof EntryMovedInSameReferenceDelta) {
-        return {
-            kind: "EntryMovedInSameReference",
-            parent: delta.parent.id,
-            reference: metaPointerFor(delta.reference),
-            oldIndex: delta.oldIndex,
-            newIndex: delta.newIndex,
-            movedTarget: idFrom(delta.movedTarget)
-        } as EntryMovedInSameReferenceSerializedDelta;
-    }
-
-    if (delta instanceof EntryMovedAndReplacedFromOtherReferenceDelta) {
-        return {
-            kind: "EntryMovedAndReplacedFromOtherReference",
-            newParent: delta.newParent.id,
-            newReference: metaPointerFor(delta.newReference),
-            newIndex: delta.newIndex,
-            movedTarget: idFrom(delta.movedTarget),
-            oldParent: delta.oldParent.id,
-            oldReference: metaPointerFor(delta.oldReference),
-            oldIndex: delta.oldIndex,
-            replacedTarget: idFrom(delta.replacedTarget)
-        } as EntryMovedAndReplacedFromOtherReferenceSerializedDelta;
-    }
-
-    if (delta instanceof EntryMovedAndReplacedFromOtherReferenceInSameParentDelta) {
-        return {
-            kind: "EntryMovedAndReplacedFromOtherReferenceInSameParent",
-            parent: delta.parent.id,
-            oldReference: metaPointerFor(delta.oldReference),
-            oldIndex: delta.oldIndex,
-            newReference: metaPointerFor(delta.newReference),
-            newIndex: delta.newIndex,
-            movedTarget: idFrom(delta.movedTarget),
-            replacedTarget: idFrom(delta.replacedTarget)
-        } as EntryMovedAndReplacedFromOtherReferenceInSameParentSerializedDelta;
-    }
-
-    if (delta instanceof EntryMovedAndReplacedInSameReferenceDelta) {
-        return {
-            kind: "EntryMovedAndReplacedInSameReference",
-            parent: delta.parent.id,
-            reference: metaPointerFor(delta.reference),
-            oldIndex: delta.oldIndex,
-            newIndex: delta.newIndex,
-            movedTarget: idFrom(delta.movedTarget),
-            replacedTarget: idFrom(delta.replacedTarget)
-        } as EntryMovedAndReplacedInSameReferenceSerializedDelta;
-    }
-
     if (delta instanceof CompositeDelta) {
         return {
             kind: "Composite",

package/src/deltas/serialization/types.g.ts

@@ -19,7 +19,7 @@
 // Modifying it by hand is useless at best, and sabotage at worst.
 
 import { LionWebId, LionWebJsonMetaPointer, LionWebJsonChunk } from "@lionweb/json";
-import { IdOrUnresolved } from "../../references.js";
+import { IdOrNull } from "../../references.js";
 
 
 export type SerializedDelta =
@@ -47,12 +47,6 @@ export type SerializedDelta =
     | ReferenceAddedSerializedDelta
     | ReferenceDeletedSerializedDelta
     | ReferenceChangedSerializedDelta
-    | EntryMovedFromOtherReferenceSerializedDelta
-    | EntryMovedFromOtherReferenceInSameParentSerializedDelta
-    | EntryMovedInSameReferenceSerializedDelta
-    | EntryMovedAndReplacedFromOtherReferenceSerializedDelta
-    | EntryMovedAndReplacedFromOtherReferenceInSameParentSerializedDelta
-    | EntryMovedAndReplacedInSameReferenceSerializedDelta
     | CompositeSerializedDelta
     | NoOpSerializedDelta
     ;
@@ -255,7 +249,7 @@ export type ReferenceAddedSerializedDelta = {
     parent: LionWebId
     reference: LionWebJsonMetaPointer
     index: number
-    newTarget: IdOrUnresolved
+    newTarget: IdOrNull
 }
 
 export type ReferenceDeletedSerializedDelta = {
@@ -263,7 +257,7 @@ export type ReferenceDeletedSerializedDelta = {
     parent: LionWebId
     reference: LionWebJsonMetaPointer
     index: number
-    deletedTarget: IdOrUnresolved
+    deletedTarget: IdOrNull
 }
 
 export type ReferenceChangedSerializedDelta = {
@@ -271,71 +265,8 @@ export type ReferenceChangedSerializedDelta = {
     parent: LionWebId
     reference: LionWebJsonMetaPointer
     index: number
-    newTarget: IdOrUnresolved
-    oldTarget: IdOrUnresolved
-}
-
-export type EntryMovedFromOtherReferenceSerializedDelta = {
-    kind: "EntryMovedFromOtherReference"
-    oldParent: LionWebId
-    oldReference: LionWebJsonMetaPointer
-    oldIndex: number
-    newParent: LionWebId
-    newReference: LionWebJsonMetaPointer
-    newIndex: number
-    movedTarget: IdOrUnresolved
-}
-
-export type EntryMovedFromOtherReferenceInSameParentSerializedDelta = {
-    kind: "EntryMovedFromOtherReferenceInSameParent"
-    parent: LionWebId
-    oldReference: LionWebJsonMetaPointer
-    oldIndex: number
-    newReference: LionWebJsonMetaPointer
-    newIndex: number
-    movedTarget: IdOrUnresolved
-}
-
-export type EntryMovedInSameReferenceSerializedDelta = {
-    kind: "EntryMovedInSameReference"
-    parent: LionWebId
-    reference: LionWebJsonMetaPointer
-    oldIndex: number
-    newIndex: number
-    movedTarget: IdOrUnresolved
-}
-
-export type EntryMovedAndReplacedFromOtherReferenceSerializedDelta = {
-    kind: "EntryMovedAndReplacedFromOtherReference"
-    newParent: LionWebId
-    newReference: LionWebJsonMetaPointer
-    newIndex: number
-    movedTarget: IdOrUnresolved
-    oldParent: LionWebId
-    oldReference: LionWebJsonMetaPointer
-    oldIndex: number
-    replacedTarget: IdOrUnresolved
-}
-
-export type EntryMovedAndReplacedFromOtherReferenceInSameParentSerializedDelta = {
-    kind: "EntryMovedAndReplacedFromOtherReferenceInSameParent"
-    parent: LionWebId
-    oldReference: LionWebJsonMetaPointer
-    oldIndex: number
-    newReference: LionWebJsonMetaPointer
-    newIndex: number
-    movedTarget: IdOrUnresolved
-    replacedTarget: IdOrUnresolved
-}
-
-export type EntryMovedAndReplacedInSameReferenceSerializedDelta = {
-    kind: "EntryMovedAndReplacedInSameReference"
-    parent: LionWebId
-    reference: LionWebJsonMetaPointer
-    oldIndex: number
-    newIndex: number
-    movedTarget: IdOrUnresolved
-    replacedTarget: IdOrUnresolved
+    newTarget: IdOrNull
+    oldTarget: IdOrNull
 }
 
 export type CompositeSerializedDelta = {

package/src/deltas/types.g.ts

@@ -280,81 +280,6 @@ export class ReferenceChangedDelta implements IDelta {
     }
 }
 
-export class EntryMovedFromOtherReferenceDelta implements IDelta {
-    constructor(
-        public readonly oldParent: INodeBase,
-        public readonly oldReference: Reference,
-        public readonly oldIndex: number,
-        public readonly newParent: INodeBase,
-        public readonly newReference: Reference,
-        public readonly newIndex: number,
-        public readonly movedTarget: SingleRef<INodeBase>
-    ) {
-    }
-}
-
-export class EntryMovedFromOtherReferenceInSameParentDelta implements IDelta {
-    constructor(
-        public readonly parent: INodeBase,
-        public readonly oldReference: Reference,
-        public readonly oldIndex: number,
-        public readonly newReference: Reference,
-        public readonly newIndex: number,
-        public readonly movedTarget: SingleRef<INodeBase>
-    ) {
-    }
-}
-
-export class EntryMovedInSameReferenceDelta implements IDelta {
-    constructor(
-        public readonly parent: INodeBase,
-        public readonly reference: Reference,
-        public readonly oldIndex: number,
-        public readonly newIndex: number,
-        public readonly movedTarget: SingleRef<INodeBase>
-    ) {
-    }
-}
-
-export class EntryMovedAndReplacedFromOtherReferenceDelta implements IDelta {
-    constructor(
-        public readonly newParent: INodeBase,
-        public readonly newReference: Reference,
-        public readonly newIndex: number,
-        public readonly movedTarget: SingleRef<INodeBase>,
-        public readonly oldParent: INodeBase,
-        public readonly oldReference: Reference,
-        public readonly oldIndex: number,
-        public readonly replacedTarget: SingleRef<INodeBase>
-    ) {
-    }
-}
-
-export class EntryMovedAndReplacedFromOtherReferenceInSameParentDelta implements IDelta {
-    constructor(
-        public readonly parent: INodeBase,
-        public readonly oldReference: Reference,
-        public readonly oldIndex: number,
-        public readonly newReference: Reference,
-        public readonly newIndex: number,
-        public readonly movedTarget: SingleRef<INodeBase>,
-        public readonly replacedTarget: SingleRef<INodeBase>
-    ) {
-    }
-}
-
-export class EntryMovedAndReplacedInSameReferenceDelta implements IDelta {
-    constructor(
-        public readonly parent: INodeBase,
-        public readonly reference: Reference,
-        public readonly oldIndex: number,
-        public readonly newIndex: number,
-        public readonly movedTarget: SingleRef<INodeBase>,
-        public readonly replacedTarget: SingleRef<INodeBase>
-    ) {
-    }
-}
-
 export class CompositeDelta implements IDelta {
     constructor(
         public readonly parts: IDelta[]

package/src/deserializer.ts

@@ -18,21 +18,21 @@
 import {
     builtinPropertyValueDeserializer,
     Classifier,
+    consoleProblemReporter,
     Containment,
-    defaultSimplisticHandler,
     Enumeration,
     MemoisingSymbolTable,
     PrimitiveType,
+    ProblemReporter,
     Property,
     PropertyValueDeserializer,
     Reference,
-    SimplisticHandler,
-    unresolved
+    referenceToSet
 } from "@lionweb/core"
 import { LionWebId, LionWebJsonChunk, LionWebJsonNode } from "@lionweb/json"
 import { byIdMap, keepDefineds } from "@lionweb/ts-utils"
 
-import { DeltaReceiver, IdMapping, ILanguageBase, INodeBase, FactoryConfiguration } from "./index.js"
+import { DeltaReceiver, FactoryConfiguration, IdMapping, ILanguageBase, INodeBase } from "./index.js"
 import { combinedLanguageBaseLookupFor } from "./factory.js"
 import { NodesToInstall } from "./linking.js"
 
@@ -62,8 +62,10 @@ export type RootsWithIdMapping = { roots: INodeBase[], idMapping: IdMapping };
 export type DeserializerConfiguration = {
     /** Default: {@link builtinPropertyValueDeserializer}. */
     propertyValueDeserializer?: PropertyValueDeserializer,
-    /** Default: {@link defaultSimplisticHandler}. */
-    problemsHandler?: SimplisticHandler
+    /** Default: {@link consoleProblemReporter}. */
+    problemReporter?: ProblemReporter
+    /** Legacy alias for {@link problemReporter}, kept for backward compatibility, and to be deprecated and removed later. */
+    problemsHandler?: ProblemReporter
 };
 
 
@@ -79,9 +81,9 @@ function nodeBaseDeserializerWithIdMapping(languageBases: ILanguageBase[], recei
  */
 function nodeBaseDeserializerWithIdMapping(configuration: FactoryConfiguration & DeserializerConfiguration): Deserializer<RootsWithIdMapping>;
 function nodeBaseDeserializerWithIdMapping(languageBasesOrConfiguration: ILanguageBase[] | (FactoryConfiguration & DeserializerConfiguration), mayBeReceiveDelta?: DeltaReceiver): Deserializer<RootsWithIdMapping> {
-    const [languageBases, receiveDelta, propertyValueDeserializer, problemsHandler] = Array.isArray(languageBasesOrConfiguration)
-        ? [languageBasesOrConfiguration, mayBeReceiveDelta, builtinPropertyValueDeserializer, defaultSimplisticHandler]
-        : [languageBasesOrConfiguration.languageBases, languageBasesOrConfiguration.receiveDelta, languageBasesOrConfiguration.propertyValueDeserializer ?? builtinPropertyValueDeserializer, languageBasesOrConfiguration.problemsHandler ?? defaultSimplisticHandler];
+    const [languageBases, receiveDelta, propertyValueDeserializer, problemReporter] = Array.isArray(languageBasesOrConfiguration)
+        ? [languageBasesOrConfiguration, mayBeReceiveDelta, builtinPropertyValueDeserializer, consoleProblemReporter]
+        : [languageBasesOrConfiguration.languageBases, languageBasesOrConfiguration.receiveDelta, languageBasesOrConfiguration.propertyValueDeserializer ?? builtinPropertyValueDeserializer, languageBasesOrConfiguration.problemReporter ?? languageBasesOrConfiguration.problemsHandler ?? consoleProblemReporter];
 
     const symbolTable = new MemoisingSymbolTable(languageBases.map(({language}) => language));
     const languageBaseFor = combinedLanguageBaseLookupFor(languageBases);
@@ -97,7 +99,7 @@ function nodeBaseDeserializerWithIdMapping(languageBasesOrConfiguration: ILangua
             const languageMessage = `language ${classifierMetaPointer.language} (${classifierMetaPointer.version})`;
             const classifier = symbolTable.entityMatching(classifierMetaPointer);
             if (classifier === undefined || !(classifier instanceof Classifier)) {
-                problemsHandler.reportProblem(`can't deserialize node with id=${id}: can't find the classifier with key ${classifierMetaPointer.key} in ${languageMessage} - skipping`);
+                problemReporter.reportProblem(`can't deserialize node with id=${id}: can't find the classifier with key ${classifierMetaPointer.key} in ${languageMessage} - skipping`);
                 return undefined;
             }
 
@@ -106,7 +108,7 @@ function nodeBaseDeserializerWithIdMapping(languageBasesOrConfiguration: ILangua
             properties.forEach(({property: propertyMetaPointer, value}) => {
                 const feature = symbolTable.featureMatching(classifierMetaPointer, propertyMetaPointer);
                 if (feature === undefined) {
-                    problemsHandler.reportProblem(`can't deserialize value for feature with key ${propertyMetaPointer.key} in ${languageMessage}: feature not found on classifier ${classifierMetaPointer.key} in language (${classifierMetaPointer.language}, ${classifierMetaPointer.version}) - skipping`);
+                    problemReporter.reportProblem(`can't deserialize value for feature with key ${propertyMetaPointer.key} in ${languageMessage}: feature not found on classifier ${classifierMetaPointer.key} in language (${classifierMetaPointer.language}, ${classifierMetaPointer.version}) - skipping`);
                 } else if (feature instanceof Property) {
                     if (feature.type instanceof PrimitiveType) {
                         node.getPropertyValueManager(feature).setDirectly(value === null ? undefined : propertyValueDeserializer.deserializeValue(value, feature));
@@ -114,32 +116,32 @@ function nodeBaseDeserializerWithIdMapping(languageBasesOrConfiguration: ILangua
                         if (value !== undefined) {
                             const literal = feature.type.literals.find((literal) => literal.key === value);
                             if (literal === undefined) {
-                                problemsHandler.reportProblem(`can't deserialize literal encoded as: ${value}`);
+                                problemReporter.reportProblem(`can't deserialize literal encoded as: ${value}`);
                             } else {
                                 node.getPropertyValueManager(feature).setDirectly(languageBaseFor(feature.type.language).enumLiteralFrom(literal));
                             }
                         }
                     }
                 } else {
-                    problemsHandler.reportProblem(`can't deserialize value for feature with key ${propertyMetaPointer.key} in ${languageMessage}: feature is not a property - skipping`);
+                    problemReporter.reportProblem(`can't deserialize value for feature with key ${propertyMetaPointer.key} in ${languageMessage}: feature is not a property - skipping`);
                 }
             });
 
             containments.forEach(({containment: containmentMetaPointer, children}) => {
                 const feature = symbolTable.featureMatching(classifierMetaPointer, containmentMetaPointer);
                 if (feature === undefined) {
-                    problemsHandler.reportProblem(`can't deserialize value for feature with key ${containmentMetaPointer.key} in ${languageMessage}: feature not found on classifier ${classifierMetaPointer.key} in language (${classifierMetaPointer.language}, ${classifierMetaPointer.version}) - skipping`);
+                    problemReporter.reportProblem(`can't deserialize value for feature with key ${containmentMetaPointer.key} in ${languageMessage}: feature not found on classifier ${classifierMetaPointer.key} in language (${classifierMetaPointer.language}, ${classifierMetaPointer.version}) - skipping`);
                 } else if (feature instanceof Containment) {
                     nodesToInstall.push([node, feature, children]);
                 } else {
-                    problemsHandler.reportProblem(`can't deserialize value for feature with key ${containmentMetaPointer.key} in ${languageMessage}: feature is not a containment - skipping`);
+                    problemReporter.reportProblem(`can't deserialize value for feature with key ${containmentMetaPointer.key} in ${languageMessage}: feature is not a containment - skipping`);
                 }
             });
 
             references.forEach(({reference: referenceMetaPointer, targets}) => {
                 const feature = symbolTable.featureMatching(classifierMetaPointer, referenceMetaPointer);
                 if (feature === undefined) {
-                    problemsHandler.reportProblem(`can't deserialize value for feature with key ${referenceMetaPointer.key} in ${languageMessage}: feature not found on classifier ${classifierMetaPointer.key} in language (${classifierMetaPointer.language}, ${classifierMetaPointer.version}) - skipping`);
+                    problemReporter.reportProblem(`can't deserialize value for feature with key ${referenceMetaPointer.key} in ${languageMessage}: feature not found on classifier ${classifierMetaPointer.key} in language (${classifierMetaPointer.language}, ${classifierMetaPointer.version}) - skipping`);
                 } else if (feature instanceof Reference) {
                     nodesToInstall.push(
                         [
@@ -152,7 +154,7 @@ function nodeBaseDeserializerWithIdMapping(languageBasesOrConfiguration: ILangua
                         ]
                     );
                 } else {
-                    problemsHandler.reportProblem(`can't deserialize value for feature with key ${referenceMetaPointer.key} in ${languageMessage}: feature is not a reference - skipping`);
+                    problemReporter.reportProblem(`can't deserialize value for feature with key ${referenceMetaPointer.key} in ${languageMessage}: feature is not a reference - skipping`);
                 }
             });
 
@@ -180,7 +182,7 @@ function nodeBaseDeserializerWithIdMapping(languageBasesOrConfiguration: ILangua
                 ids.forEach((id) => {
                     const nodeToInstall = lookupNodeById(id);
                     if (nodeToInstall === undefined) {
-                        problemsHandler.reportProblem(`couldn't resolve the child with id=${id} of the "${feature.name}" containment feature on the node with id=${node.id}`);
+                        problemReporter.reportProblem(`couldn't resolve the child with id=${id} of the "${feature.name}" containment feature on the node with id=${node.id}`);
                     } else {
                         valueManager.addDirectly(nodeToInstall);
                         nodeToInstall.attachTo(node, feature);
@@ -193,8 +195,8 @@ function nodeBaseDeserializerWithIdMapping(languageBasesOrConfiguration: ILangua
                 ids.forEach((id) => {
                     const nodeToInstall = lookupNodeById(id);
                     if (nodeToInstall === undefined) {
-                        problemsHandler.reportProblem(`couldn't resolve the target with id=${id} of the "${feature.name}" reference feature on the node with id=${node.id}`);
-                        valueManager.addDirectly(unresolved);
+                        problemReporter.reportProblem(`couldn't resolve the target with id=${id} of the "${feature.name}" reference feature on the node with id=${node.id}`);
+                        valueManager.addDirectly(referenceToSet());
                     } else {
                         valueManager.addDirectly(nodeToInstall);
                     }
@@ -206,7 +208,7 @@ function nodeBaseDeserializerWithIdMapping(languageBasesOrConfiguration: ILangua
                 ids.forEach((id) => {
                     const nodeToInstall = lookupNodeById(id);
                     if (nodeToInstall === undefined) {
-                        problemsHandler.reportProblem(`couldn't resolve the annotation with id=${id} on the node with id=${node.id}`);
+                        problemReporter.reportProblem(`couldn't resolve the annotation with id=${id} on the node with id=${node.id}`);
                     } else {
                         valueManager.addDirectly(nodeToInstall);
                         nodeToInstall.attachTo(node, feature);

package/src/duplicator.ts

@@ -15,7 +15,17 @@
 // SPDX-FileCopyrightText: 2025 TRUMPF Laser SE and other contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { Containment, Feature, idOf, Link, MultiRef, Property, Reference, SingleRef, unresolved } from "@lionweb/core"
+import {
+    Containment,
+    Feature,
+    idOf,
+    isUnresolvedReference,
+    Link,
+    MultiRef,
+    Property,
+    Reference,
+    SingleRef
+} from "@lionweb/core"
 import { LionWebId } from "@lionweb/json"
 import { asArray } from "@lionweb/ts-utils"
 
@@ -55,7 +65,7 @@ export const deepDuplicateWith = (duplicateNode: NodeDuplicator): Duplicator =>
                     duplicatedNode.getPropertyValueManager(feature).setDirectly(value);
                 } else if (feature instanceof Link) {
                     const values = asArray(value as (MultiRef<INodeBase> | SingleRef<INodeBase>));
-                    const resolvedValues = values.filter((value) => value !== unresolved) as INodeBase[];
+                    const resolvedValues = values.filter((value) => !isUnresolvedReference(value)) as INodeBase[];
                     if (resolvedValues.length > 0) {
                         nodesToInstall.push([
                             duplicatedNode,

package/src/id-mapping.ts

@@ -15,11 +15,11 @@
 // SPDX-FileCopyrightText: 2025 TRUMPF Laser SE and other contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { SingleRef, unresolved } from "@lionweb/core"
+import { referenceToSet, SingleRef } from "@lionweb/core"
 import { LionWebId } from "@lionweb/json"
 
 import { INodeBase } from "./base-types.js"
-import { IdOrUnresolved } from "./references.js"
+import { IdOrNull } from "./references.js"
 
 
 /**
@@ -63,10 +63,10 @@ export class IdMapping {
      * @return the {@link INodeBase node} referenced from the given {@link LionWebId ID},
      * or `unresolved` if `unresolved` was passed in or no node with the given ID was registered.
      */
-    fromRefId = (idOrUnresolved: IdOrUnresolved): SingleRef<INodeBase> =>
-        idOrUnresolved === unresolved
-            ? unresolved
-            : (this.nodesById[idOrUnresolved] ?? unresolved);
+    fromRefId = (idOrNull: IdOrNull): SingleRef<INodeBase> =>
+        idOrNull === null
+            ? referenceToSet()
+            : (this.nodesById[idOrNull] ?? referenceToSet());
 
     /**
      * Updates this {@link IdMapping} with the given `node` *and all its descendants* (recursively).

package/src/index.ts

@@ -20,14 +20,14 @@ export * from "./convenience.js";
 export * from "./deltas/index.js";
 export * from "./deserializer.js";
 export { deepDuplicateWith } from "./duplicator.js";
-export * from "./id-mapping.js";
 export { combinedFactoryFor } from "./factory.js";
 export { Forest, ObservableForest } from "./forest.js";
+export * from "./id-mapping.js";
 // skip linking.js: see comment there
 export * from "./LionCore_builtins.g.js";
-export type { IdOrUnresolved } from "./references.js";
+export type { IdOrNull } from "./references.js";
 export { idFrom } from "./references.js";
-export { propertyValueSerializerWith, serializeNodeBases } from "./serializer.js";
+export { nodeBaseReader, propertyValueSerializerWith, serializeNodeBases } from "./serializer.js";
 export { asTreeTextWith } from "./textualizer.js";
 export * from "./value-managers/index.js";
 

package/src/references.ts

@@ -15,7 +15,7 @@
 // SPDX-FileCopyrightText: 2025 TRUMPF Laser SE and other contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { SingleRef, unresolved } from "@lionweb/core"
+import { isUnresolvedReference, SingleRef } from "@lionweb/core"
 import { LionWebId } from "@lionweb/json"
 
 import { INodeBase } from "./base-types.js"
@@ -24,12 +24,12 @@ import { INodeBase } from "./base-types.js"
 /**
  * A type that expresses a value is either an {@link LionWebId} or a value to indicate that resolution to a node previously failed.
  */
-export type IdOrUnresolved = LionWebId | typeof unresolved;
+export type IdOrNull = LionWebId | null
 
 
 /**
- * @return the ID of a given reference to a {@link INodeBase}, or {@link unresolved} if that reference was previously unresolved.
+ * @return the ID of a given reference to a {@link INodeBase}, or `null` if that reference was previously unresolved.
  */
-export const idFrom = (ref: SingleRef<INodeBase>): IdOrUnresolved =>
-    ref === unresolved ? unresolved : ref.id
+export const idFrom = (ref: SingleRef<INodeBase>): IdOrNull =>
+    isUnresolvedReference(ref) ? null : ref.id