node-opcua-address-space 2.181.0 → 2.182.0

package/impl/base_node_private.ts

@@ -30,6 +30,7 @@ import {
     type LocalizedText,
     type LocalizedTextLike,
     NodeClass,
+    type QualifiedName,
     ResultMask
 } from "node-opcua-data-model";
 import type { DataValue } from "node-opcua-data-value";
@@ -516,7 +517,7 @@ export function VariableOrVariableType_toString(this: UAVariableType | UAVariabl
 }
 
 /**
- *
+ * A subtype (or an instance) may re-declare a child that its base type already declares:
  *
  *    MyDeriveType  ------------------- -> MyBaseType    --------------> TopologyElementType
  *        |                                   |                                   |
@@ -525,137 +526,71 @@ export function VariableOrVariableType_toString(this: UAVariableType | UAVariabl
  *                  +- Foo1                            |
  *                                                     +- Bar
  *
- *    Instance
- *
- * @param newParent
- * @param node
- * @param copyAlsoModellingRules
- * @param optionalFilter
- * @param extraInfo
- * @param browseNameMap
- * @returns
+ * The instance gets ONE ParameterSet, cloned from the nearest declaration (Foo1), into which the
+ * base declarations are merged (Bar): see _base_declarations_of and _merge_base_declaration.
  */
-function _clone_children_on_template(
-    nodeToClone: UAObject | UAVariable | UAMethod | UAObjectType | UAVariableType,
-    newParent: BaseNode,
-    node: BaseNode,
-    copyAlsoModellingRules: boolean,
-    optionalFilter: CloneFilter,
-    extraInfo: CloneExtraInfo
-) {
-    /**
-     * the type definition node of the node to clone
-     */
-    const nodeToCloneTypeDefinition =
-        nodeToClone.nodeClass === NodeClass.ObjectType || nodeToClone.nodeClass === NodeClass.VariableType
-            ? nodeToClone.subtypeOfObj
-            : null;
-    if (!nodeToCloneTypeDefinition) return;
-
-    // c8 ignore next
-    doTrace &&
-        traceLog(
-            extraInfo?.pad(),
-            chalk.gray(
-                "-------------------- now cloning children on template ",
-                node.browseName.toString(),
-                node.nodeId.toString(),
-                nodeToCloneTypeDefinition.browseName.toString()
-            )
-        );
-
-    const namespace = newParent.namespace;
-
-    /**
-     * the child node of the new parent that match the node to clone or enrich
-     */
-    const newParentChild = newParent.getChildByName(node.browseName);
-    if (!newParentChild) {
-        return;
+/**
+ * the declarations, on the supertypes of `type`, of the child that `type` declares under
+ * `browseName`, nearest supertype first; none when `type` is not a type
+ */
+function _base_declarations_of(type: BaseNode, browseName: QualifiedName): BaseNode[] {
+    if (type.nodeClass !== NodeClass.ObjectType && type.nodeClass !== NodeClass.VariableType) {
+        return [];
     }
-    // we have found a matching child on the new parent.
-    // the mission is to enrich this child node with components and properties that
-    // exist also in the template
-
-    let typeDefinitionNode: UAVariableType | UAObjectType | null = nodeToCloneTypeDefinition;
-    while (typeDefinitionNode) {
-        // c8 ignore next
-        doTrace &&
-            traceLog(
-                extraInfo?.pad(),
-                chalk.green(
-                    "-------------------- now cloning children on ",
-                    newParentChild.browseName.toString(),
-                    newParentChild.nodeId.toString(),
-                    " (child of ",
-                    node.browseName.toString(),
-                    node.nodeId.toString(),
-                    ") from ",
-                    typeDefinitionNode.browseName.toString()
-                )
-            );
-
-        // Find aggregates with same browseName as node. Do not search children as this includes nodes with HasSubType relation which we do
-        // not want. See issue #1326.
-        const aggregates = typeDefinitionNode.getAggregates().filter((n) => n.browseName.equals(node.browseName));
-        const typeDefinitionChild = aggregates.length > 0 ? aggregates[0] : null;
-        if (typeDefinitionChild) {
-            const references = typeDefinitionChild.findReferencesEx("Aggregates", BrowseDirection.Forward);
-
-            for (const ref of references) {
-                const grandChild = ref.node as UAVariable | UAObject | UAMethod;
-                if (grandChild.modellingRule === "MandatoryPlaceholder" || grandChild.modellingRule === "OptionalPlaceholder")
-                    continue;
-                // if not already node present in new Parent => just ignore
-                const hasAlready = newParentChild.getChildByName(grandChild.browseName) !== null;
-                if (!hasAlready) {
-                    if (optionalFilter && node && !optionalFilter.shouldKeep(node)) {
-                        // c8 ignore next
-                        doTrace &&
-                            traceLog(
-                                extraInfo.pad(),
-                                "skipping optional ",
-                                node.browseName.toString(),
-                                "that doesn't appear in the filter"
-                            );
-                        continue; // skip this node
-                    }
-
-                    const options = {
-                        namespace,
-                        references: [
-                            new ReferenceImpl({
-                                referenceType: ref.referenceType,
-                                isForward: false,
-                                nodeId: newParentChild.nodeId
-                            })
-                        ],
-                        copyAlsoModellingRules
-                    };
-
-                    const alreadyCloned = extraInfo.getCloned({
-                        originalParent: nodeToClone,
-                        clonedParent: newParent,
-                        originalNode: grandChild
-                    });
-                    if (alreadyCloned) {
-                        alreadyCloned.addReference({
-                            referenceType: ref.referenceType,
-                            isForward: false,
-                            nodeId: newParentChild.nodeId
-                        });
-                    } else {
-                        const clonedGrandChild = grandChild.clone(options, optionalFilter, extraInfo);
-                        extraInfo.registerClonedObject({
-                            originalNode: grandChild,
-                            clonedNode: clonedGrandChild
-                        });
-                    }
-                }
-            }
+    const result: BaseNode[] = [];
+    let base = (type as UAObjectType | UAVariableType).subtypeOfObj;
+    while (base) {
+        // aggregates only: a child lookup would also follow HasSubtype (issue #1326)
+        const declaration = base.getAggregates().find((n) => n.browseName.equals(browseName));
+        if (declaration) {
+            result.push(declaration);
         }
-        typeDefinitionNode = typeDefinitionNode.subtypeOfObj;
+        base = base.subtypeOfObj;
     }
+    return result;
+}
+
+/**
+ * record `cloned` as the clone of `original` and, by browse name, each child the clone already
+ * has as the clone of the matching child of `original`, recursively: a later reference to any
+ * of them then lands on the existing node instead of a second copy
+ */
+function _register_existing_children(original: BaseNode, cloned: BaseNode, extraInfo: CloneExtraInfo): void {
+    extraInfo.registerClonedObject({ originalNode: original, clonedNode: cloned });
+    for (const ref of original.findReferencesEx("Aggregates", BrowseDirection.Forward)) {
+        const child = ref.node;
+        if (!child) continue;
+        const existing = cloned.getChildByName(child.browseName);
+        if (!existing) continue;
+        _register_existing_children(child, existing, extraInfo);
+    }
+}
+
+/**
+ * `clonedNode` was cloned from a declaration that shadows `baseDeclaration` (a subtype or an
+ * instance re-declaring a child of a base type). What the clone already has is recorded as the
+ * clone of the base declaration's same-named children; what the base declaration adds is cloned
+ * in, subject to the same filter and the same browse-name guard as the clone's own children.
+ */
+function _merge_base_declaration(
+    baseDeclaration: BaseNode,
+    clonedNode: BaseNode,
+    copyAlsoModellingRules: boolean,
+    optionalFilter: CloneFilter,
+    extraInfo: CloneExtraInfo,
+    browseNameMap: Set<string>
+): void {
+    // c8 ignore next
+    doTrace && traceLog(extraInfo.pad(), "merging base declaration ", fullPath2(baseDeclaration), " into ", fullPath2(clonedNode));
+    _register_existing_children(baseDeclaration, clonedNode, extraInfo);
+    _clone_hierarchical_references(
+        baseDeclaration as UAObject | UAVariable | UAMethod,
+        clonedNode as UAObject | UAVariable | UAMethod,
+        copyAlsoModellingRules,
+        optionalFilter,
+        extraInfo,
+        browseNameMap
+    );
 }
 
 /*
@@ -707,27 +642,31 @@ function _clone_collection_new(
         }
         const key = `${newParent.nodeId.toString()}(${newParent.browseName.toString()})/${node.browseName.toString()}`;
         if (browseNameMap?.has(key)) {
-            _clone_children_on_template(nodeToClone, newParent, node, copyAlsoModellingRules, optionalFilter, extraInfo);
-            doTrace &&
-                traceLog(
-                    extraInfo.pad(),
-                    "skipping required node with same browseName",
-                    fullPath2(node),
-                    "because it has already been cloned",
-                    "key=",
-                    key
+            // a same-named child was cloned already, from a nearer declaration: this one is a
+            // base declaration of it, merge what it adds
+            doTrace && traceLog(extraInfo.pad(), "node with same browseName already cloned, merging", fullPath2(node), "key=", key);
+            const existing = newParent.getChildByName(node.browseName);
+            if (existing) {
+                _merge_base_declaration(
+                    node,
+                    existing,
+                    copyAlsoModellingRules,
+                    optionalFilter.filterFor(existing as UAObject | UAVariable | UAMethod),
+                    extraInfo,
+                    new Set<string>()
                 );
-
+            }
             continue; // skipping node with same browseName
         }
         browseNameMap?.add(key);
 
         // assert(reference.isForward);
         // assert(reference.referenceType instanceof NodeId, "" + reference.referenceType.toString());
-        const options = {
+        const options: CloneOptions = {
             namespace,
             references: [new ReferenceImpl({ referenceType: reference.referenceType, isForward: false, nodeId: newParent.nodeId })],
-            copyAlsoModellingRules
+            copyAlsoModellingRules,
+            baseDeclarations: _base_declarations_of(nodeToClone, node.browseName)
         };
 
         const alreadyCloned = extraInfo.getCloned({ originalParent: nodeToClone, clonedParent: newParent, originalNode: node });
@@ -746,8 +685,10 @@ function _clone_collection_new(
                     fullPath2(newParent)
                 );
 
-            const hasReference =
-                alreadyCloned.findReferencesExAsObject(reference.referenceType, BrowseDirection.Inverse).length > 0;
+            // this parent, not any parent: a shared child may already hang under another one
+            const hasReference = alreadyCloned
+                .findReferences(reference.referenceType, false)
+                .some((r) => sameNodeId(r.nodeId, newParent.nodeId));
             if (!hasReference) {
                 alreadyCloned.addReference({
                     referenceType: reference.referenceType,
@@ -791,10 +732,6 @@ function _clone_collection_new(
                     `${fullPath2(clonedNode)}`
                 );
 
-            extraInfo.level++;
-            _clone_children_on_template(nodeToClone, newParent, node, copyAlsoModellingRules, optionalFilter, extraInfo);
-            extraInfo.level--;
-
             // also clone or instantiate interface members that may be required in the optionals
             extraInfo.level++;
             _cloneInterface(nodeToClone, newParent, node, optionalFilter, extraInfo, browseNameMap);
@@ -1123,6 +1060,20 @@ export function _clone<T extends UAObject | UAVariable | UAMethod, O>(
             browseNameMap
         );
 
+        // what the base types declare under the same name, before the type definition is explored:
+        // the base declaration overrides the type definition's children, so the later walk of the
+        // type definition finds them present instead of cloning them a second time
+        for (const baseDeclaration of options.baseDeclarations || []) {
+            _merge_base_declaration(
+                baseDeclaration,
+                clonedNode,
+                options.copyAlsoModellingRules,
+                newFilter,
+                extraInfo,
+                browseNameMap
+            );
+        }
+
         if (originalNode.nodeClass === NodeClass.Object || originalNode.nodeClass === NodeClass.Variable) {
             let typeDefinitionNode: UAVariableType | UAObjectType | null = originalNode.typeDefinitionObj;
 

package/impl/data_access/ua_multistate_discrete_impl.ts

@@ -43,7 +43,7 @@ export class UAMultiStateDiscreteImplBase<T, DT extends DataType>
      * The EnumStrings property, installed as a child node by the address space rather than
      * assigned by this constructor - hence `declare`, which emits nothing.
      */
-    public declare readonly enumStrings: UAProperty<LocalizedText[], DataType.LocalizedText>;
+    declare public readonly enumStrings: UAProperty<LocalizedText[], DataType.LocalizedText>;
 
     public getValue(): number {
         // MultiStateDiscrete fixes its value to UInt32 (OPC 10000-8), whatever T says

package/impl/data_access/ua_multistate_value_discrete_impl.ts

@@ -94,8 +94,8 @@ export class UAMultiStateValueDiscreteImplBase<T extends Number, DT extends Data
      * Properties installed as child nodes by the address space rather than assigned by this
      * constructor - hence `declare`, which emits nothing.
      */
-    public declare readonly enumValues: UAProperty<DTEnumValue[], DataType.ExtensionObject>;
-    public declare readonly valueAsText: UAProperty<LocalizedText, DataType.LocalizedText>;
+    declare public readonly enumValues: UAProperty<DTEnumValue[], DataType.ExtensionObject>;
+    declare public readonly valueAsText: UAProperty<LocalizedText, DataType.LocalizedText>;
     public setValue(value: string | number | Int64, options?: ISetStateOptions): void {
         if (typeof value === "string") {
             const enumValues = this.enumValues.readValue().value.value;

package/impl/data_access/ua_two_state_discrete_impl.ts

@@ -24,8 +24,8 @@ export class UATwoStateDiscreteImplBase extends UAVariableImplT<boolean, DataTyp
      * Properties installed as child nodes by the address space rather than assigned by this
      * constructor - hence `declare`, which emits nothing.
      */
-    public declare readonly falseState: UAProperty<LocalizedText, DataType.LocalizedText>;
-    public declare readonly trueState: UAProperty<LocalizedText, DataType.LocalizedText>;
+    declare public readonly falseState: UAProperty<LocalizedText, DataType.LocalizedText>;
+    declare public readonly trueState: UAProperty<LocalizedText, DataType.LocalizedText>;
     /*
      * @private
      */

package/impl/nodeset_tools/construct_namespace_dependency.ts

@@ -367,7 +367,11 @@ export function _constructNamespaceTranslationTable(dependency: INamespace[], ex
     let counter = 0;
     translationTable.set(dependency[0].index, counter++);
     //
-    if (exportedNamespace) {
+    // the exported namespace goes next, at 1 -- unless it *is* the UA namespace, which the line
+    // above has already placed at 0. Overwriting it there sent every ns0 id to ns=1, an index the
+    // <NamespaceUris> of such a document never declares, which is why exporting the UA namespace
+    // used to produce a document that could not be loaded back
+    if (exportedNamespace && !translationTable.has(exportedNamespace.index)) {
         translationTable.set(exportedNamespace.index, counter++);
     }
     for (let i = 1; i < dependency.length; i++) {

package/impl/nodeset_tools/nodeset_to_records.ts

@@ -75,7 +75,6 @@ import {
 } from "./construct_namespace_dependency.js";
 import {
     _dumpVariantExtensionObjectValue_Body,
-    _isDefaultValue,
     coerceInt64ToInt32,
     initXmlWriterEx,
     makeTypeXsd,
@@ -362,6 +361,9 @@ class RecordExporter {
             browseName: this.tq(node.browseName),
             references: this.referencesOf(node)
         };
+        if (node.releaseStatus) {
+            record.releaseStatus = node.releaseStatus;
+        }
         const parentNode = this.parentOf(node);
         if (parentNode && parentNode.nodeId.namespace <= node.nodeId.namespace) {
             record.parentNodeId = this.t(parentNode.nodeId);
@@ -380,7 +382,10 @@ class RecordExporter {
                 record.userAccessLevel = variable.userAccessLevel.toString();
             }
         }
-        if (node.accessRestrictions !== undefined) record.accessRestrictions = node.accessRestrictions.toString();
+        // the declared spelling first: the loader's accessRestrictions option governs what is
+        // enforced, not what the document said, and only the latter belongs in an export
+        const accessRestrictions = node.declaredAccessRestrictions ?? node.accessRestrictions?.toString();
+        if (accessRestrictions !== undefined) record.accessRestrictions = accessRestrictions;
         if (node.rolePermissions !== undefined && node.rolePermissions.length === 0) record.hasNoPermissions = true;
         if (Object.hasOwn(node, "minimumSamplingInterval")) {
             const minimumSamplingInterval = (node as UAVariable).minimumSamplingInterval;
@@ -517,6 +522,25 @@ class RecordExporter {
     /** the fields as the XML loader's definition parser shapes them: an absent rank is -1, an absent type BaseDataType */
     private definitionOf(node: UADataType): NodesetDataTypeDefinitionRecord | undefined {
         const baseDataType = this.t(resolveNodeId(DataTypeIds.BaseDataType));
+        // an OptionSet is neither an enumeration nor a structure to node-opcua -- it is a plain
+        // UInt16 or UInt32 subtype -- so the only account of it is the one the loader kept
+        const asImpl = node as unknown as {
+            isOptionSetDataType?: boolean;
+            declaredDefinitionFields?: NodesetDefinitionField[];
+            declaredDefinitionName?: string;
+        };
+        // what the document called this definition, or -- for a DataType built here, which never
+        // had a declaration -- the browse name, which is the only name available
+        const definitionName = asImpl.declaredDefinitionName ?? this.b(node.browseName);
+        if (asImpl.isOptionSetDataType && asImpl.declaredDefinitionFields) {
+            const fields = asImpl.declaredDefinitionFields.map((f) => {
+                const field: NodesetDefinitionField = { ...f, allowSubTypes: f.allowSubTypes ?? false };
+                field.valueRank = f.valueRank ?? -1;
+                field.dataType = f.dataType ? this.t(f.dataType as unknown as NodeId) : baseDataType;
+                return field;
+            });
+            return { name: definitionName, isOptionSet: true, fields };
+        }
         if (node.isEnumeration()) {
             const enumDefinition = node.getEnumDefinition();
             const fields: NodesetDefinitionField[] = (enumDefinition.fields || []).map((f) => {
@@ -527,29 +551,38 @@ class RecordExporter {
                 field.dataType = baseDataType;
                 return field;
             });
-            return { name: this.b(node.browseName), fields };
+            return { name: definitionName, fields };
         }
         if (node.isStructure()) {
             const definition = node.getStructureDefinition();
-            const base = node.subtypeOfObj ? (node.subtypeOfObj as UADataType).getStructureDefinition() : null;
+            // a structure's supertype need not be a structure: `Structure` itself subtypes BaseDataType,
+            // which has no definition at all. Asking it for one threw, and took the whole export with it
+            const baseNode = node.subtypeOfObj as UADataType | null;
+            const base = baseNode?.isStructure() ? baseNode.getStructureDefinition() : null;
             const nbFieldsInBase = base ? base.fields?.length || 0 : 0;
+            // Part 3 8.51: in a *WithSubtypedValues structure, isOptional does not mean optional --
+            // it is where "subtyping allowed" is held. The document spells that AllowSubTypes, and
+            // says nothing about IsOptional there, so the two must be swapped back on the way out
+            const subtypedValues =
+                definition.structureType === StructureType.StructureWithSubtypedValues ||
+                definition.structureType === StructureType.UnionWithSubtypedValues;
             const fields: NodesetDefinitionField[] = [];
             const all = definition.fields || [];
             for (let index = nbFieldsInBase; index < all.length; index++) {
                 const f = all[index];
                 const field: NodesetDefinitionField = {
                     name: f.name as string,
-                    allowSubTypes: !!(f as unknown as { allowSubTypes?: boolean }).allowSubTypes
+                    allowSubTypes: subtypedValues ? !!f.isOptional : !!(f as unknown as { allowSubTypes?: boolean }).allowSubTypes
                 };
                 if (f.description?.text?.length) field.description = { text: f.description.text } as unknown as string;
                 field.valueRank = f.valueRank === undefined || f.valueRank === -1 ? -1 : f.valueRank;
                 if (f.arrayDimensions && f.arrayDimensions.length > 0) field.arrayDimensions = f.arrayDimensions;
-                if (f.isOptional) field.isOptional = f.isOptional;
+                if (f.isOptional && !subtypedValues) field.isOptional = f.isOptional;
                 if (f.maxStringLength !== undefined && f.maxStringLength !== 0) field.maxStringLength = f.maxStringLength;
                 field.dataType = f.dataType && !f.dataType.isEmpty() ? this.t(f.dataType) : baseDataType;
                 fields.push(field);
             }
-            const record: NodesetDataTypeDefinitionRecord = { name: this.b(node.browseName), fields };
+            const record: NodesetDataTypeDefinitionRecord = { name: definitionName, fields };
             if (definition.structureType === StructureType.Union) record.isUnion = true;
             return record;
         }
@@ -565,7 +598,10 @@ class RecordExporter {
         this.arrayDimensionsOf(node, record);
         if (this.addressSpace.findNode(node.dataType)) record.dataType = this.t(node.dataType);
         const dataValue = (node as UAVariableImpl).$dataValue;
-        if (dataValue?.value && !dataValue.statusCode.equals(StatusCodes.BadWaitingForInitialData)) {
+        // a value the loader made up for a variable the document left unvalued is not the document's
+        // to write back; see valueWasSynthesized in nodeset_record_applier
+        const synthesized = (node as unknown as { valueWasSynthesized?: boolean }).valueWasSynthesized;
+        if (dataValue?.value && !synthesized && !dataValue.statusCode.equals(StatusCodes.BadWaitingForInitialData)) {
             const value = this.valueOf(node, dataValue.value);
             if (value) record.value = value;
         }
@@ -590,8 +626,14 @@ class RecordExporter {
     }
 
     private arrayDimensionsOf(node: UAVariable | UAVariableType, record: NodesetNodeRecord): void {
-        if (!node.arrayDimensions) return;
-        if (node.valueRank === -1 || (node.arrayDimensions.length === 1 && node.arrayDimensions[0] === 0)) return;
+        // ArrayDimensions="0" is written only when the document declared it: node-opcua synthesizes [0]
+        // on the variables it generates, so writing it unconditionally would invent the attribute on
+        // every generated node. See arrayDimensionsWereDeclared in nodeset_record_applier
+        if (!node.arrayDimensions || node.valueRank <= 0) return;
+        // all-zero dimensions are what node-opcua synthesizes when nobody declared any, at whatever
+        // rank: [0] for a one-dimensional value, [0,0] for a matrix
+        const degenerate = node.arrayDimensions.every((d) => d === 0);
+        if (degenerate && !(node as unknown as { arrayDimensionsWereDeclared?: boolean }).arrayDimensionsWereDeclared) return;
         record.arrayDimensions = node.arrayDimensions;
     }
 
@@ -605,7 +647,9 @@ class RecordExporter {
         this.markVisited(node);
         this.dumpReferencedNodes(node);
         const record = this.common(node);
-        if (node.eventNotifier) record.eventNotifier = node.eventNotifier;
+        // typeof, not truthiness: a node with a child called "EventNotifier" resolves the name to that
+        // child through the shared child accessors, so this is a BaseNode there, not the attribute
+        if (typeof node.eventNotifier === "number" && node.eventNotifier !== 0) record.eventNotifier = node.eventNotifier;
         this.records.push(record);
         this.dumpAggregates(node);
     }
@@ -615,8 +659,10 @@ class RecordExporter {
         this.markVisited(node);
         this.dumpReferencedNodes(node);
         const record = this.common(node);
-        const eventNotifier = (node as unknown as { eventNotifier?: number }).eventNotifier;
-        if (eventNotifier) record.eventNotifier = eventNotifier;
+        // typeof, not truthiness: a node with a child called "EventNotifier" resolves the name to that
+        // child through the shared child accessors, so this is a BaseNode there, not the attribute
+        const eventNotifier = (node as unknown as { eventNotifier?: unknown }).eventNotifier;
+        if (typeof eventNotifier === "number" && eventNotifier !== 0) record.eventNotifier = eventNotifier;
         this.records.push(record);
         this.dumpAggregates(node);
         this.section(`ObjectType - ${this.b(node.browseName)} }}}}`);
@@ -634,9 +680,9 @@ class RecordExporter {
     private dumpView(node: BaseNode): void {
         this.markVisited(node);
         const record = this.common(node);
-        const view = node as unknown as { containsNoLoops?: boolean; eventNotifier?: number };
+        const view = node as unknown as { containsNoLoops?: boolean; eventNotifier?: unknown };
         if (view.containsNoLoops) record.containsNoLoops = true;
-        if (view.eventNotifier) record.eventNotifier = view.eventNotifier;
+        if (typeof view.eventNotifier === "number" && view.eventNotifier !== 0) record.eventNotifier = view.eventNotifier;
         this.records.push(record);
         this.dumpAggregates(node);
     }
@@ -675,8 +721,12 @@ class RecordExporter {
     private valueOf(node: UAVariable | UAVariableType, variant: Variant): VariantOptions | undefined {
         if (!(variant instanceof Variant)) return undefined;
         if (variant.dataType === DataType.Null) return undefined;
+        // a null value is nothing to write down, whatever its declared data type
+        if (variant.value === null || variant.value === undefined) return undefined;
         if (!this.addressSpace.findDataType(node.dataType)) return undefined;
-        if (_isDefaultValue(variant)) return undefined;
+        // no _isDefaultValue test here: it dropped every zero and every empty string, which threw
+        // away the ones the document actually declared in order to suppress the ones the loader
+        // made up. valueWasSynthesized now separates the two, so a declared "" survives the trip
         const element = (v: unknown) => this.elementOf(node, variant.dataType, v);
         const out: VariantOptions = { dataType: variant.dataType, arrayType: variant.arrayType };
         if (variant.arrayType === VariantArrayType.Scalar) {