node-opcua-address-space 2.183.1 → 2.184.0

package/impl/state_machine/finite_state_machine.ts

@@ -65,6 +65,50 @@ function getComponentOfType(typeDef: UAObjectType, typedefinition: UAObjectType)
     return components_parts as UAObject[];
 }
 
+/**
+ * OPC 10000-16 requires that a StateMachineType (or subtype) that raises events declares a
+ * GeneratesEvent reference to the EventType(s) it raises, on the type itself or on one of its
+ * super types (the CTT's "Base Info State Machine Instance / 001.js" script walks the instance's
+ * type up to StateMachineType looking for one such reference and accepts BaseEventType or any
+ * subtype as the target).
+ *
+ * node-opcua's finite state machine implementation always raises a "TransitionEventType" event
+ * when the current state changes (see FiniteStateMachineType#setState), for every state machine
+ * instance, whichever subtype of FiniteStateMachineType it is instantiated from. Declaring the
+ * reference once on FiniteStateMachineType therefore covers every state machine exposed by the
+ * server (ExclusiveLimitStateMachineType included), matching the CTT's parent walk.
+ *
+ * This is called from every state machine's _post_initialize, so it must be idempotent.
+ */
+function ensureFiniteStateMachineTypeGeneratesTransitionEvent(finiteStateMachineType: UAObjectType): void {
+    const addressSpace = finiteStateMachineType.addressSpace;
+
+    // Some minimal test fixtures load only a handful of namespace-0 nodes and do not carry the
+    // GeneratesEvent ReferenceType or TransitionEventType ObjectType at all: nothing to attach to.
+    if (!addressSpace.findReferenceType("GeneratesEvent")) {
+        return;
+    }
+    const transitionEventType = addressSpace.findObjectType("TransitionEventType");
+    if (!transitionEventType) {
+        /* c8 ignore next */
+        return;
+    }
+
+    const hasReferenceAlready = finiteStateMachineType
+        .findReferencesEx("GeneratesEvent", BrowseDirection.Forward)
+        .some((ref) => sameNodeId(ref.nodeId, transitionEventType.nodeId));
+
+    if (hasReferenceAlready) {
+        return;
+    }
+
+    finiteStateMachineType.addReference({
+        referenceType: "GeneratesEvent",
+        isForward: true,
+        nodeId: transitionEventType.nodeId
+    });
+}
+
 const defaultPredicate = (transitions: UATransition[], fromState: UAState, toState: UAState) => {
     if (transitions.length === 0) {
         return null;
@@ -88,13 +132,13 @@ export function getFiniteStateMachineTypeStates(uaFiniteStateMachineType: UAObje
     const addressSpace = uaFiniteStateMachineType.addressSpace;
 
     const initialStateType = addressSpace.findObjectType("InitialStateType");
-    // c8 ignore next
+    /* c8 ignore next */
     if (!initialStateType) {
         throw new Error("cannot find InitialStateType");
     }
 
     const stateType = addressSpace.findObjectType("StateType");
-    // c8 ignore next
+    /* c8 ignore next */
     if (!stateType) {
         throw new Error("cannot find StateType");
     }
@@ -109,7 +153,7 @@ export function getFiniteStateMachineTypeTransitions(uaFiniteStateMachineType: U
     const addressSpace = uaFiniteStateMachineType.addressSpace;
 
     const transitionType = addressSpace.findObjectType("TransitionType");
-    // c8 ignore next
+    /* c8 ignore next */
     if (!transitionType) {
         throw new Error("cannot find TransitionType");
     }
@@ -178,7 +222,7 @@ export class UAStateMachineImplBase extends UAObjectImpl implements UAStateMachi
         const typeDef = this.typeDefinitionObj;
 
         const comp = getComponentOfType(typeDef, initialStateType);
-        // c8 ignore next
+        /* c8 ignore next */
         if (comp.length > 1) {
             throw new Error(" More than 1 initial state in stateMachine");
         }
@@ -214,7 +258,7 @@ export class UAStateMachineImplBase extends UAObjectImpl implements UAStateMachi
         // to be executed there must be a transition from currentState to toState
         const transition = this.findTransitionNode(this.currentStateNode, toStateNode, predicate);
         if (!transition) {
-            // c8 ignore next
+            /* c8 ignore next */
             if (doDebug) {
                 debugLog(" No transition from ", this.currentStateNode.browseName.toString(), " to ", toStateNode.toString());
             }
@@ -242,18 +286,18 @@ export class UAStateMachineImplBase extends UAObjectImpl implements UAStateMachi
             return null;
         }
 
-        // c8 ignore next
+        /* c8 ignore next */
         if (_fromStateNode.nodeClass !== NodeClass.Object) {
             throw new Error("Internal Error");
         }
-        // c8 ignore next
+        /* c8 ignore next */
         if (_toStateNode && _toStateNode.nodeClass !== NodeClass.Object) {
             throw new Error("Internal Error");
         }
 
         const stateType = addressSpace.findObjectType("StateType");
 
-        // c8 ignore next
+        /* c8 ignore next */
         if (!stateType) {
             throw new Error("Cannot find StateType");
         }
@@ -270,7 +314,7 @@ export class UAStateMachineImplBase extends UAObjectImpl implements UAStateMachi
             // cannot find a transition from fromState to toState
             return null;
         }
-        // c8 ignore next
+        /* c8 ignore next */
         if (transitions.length > 1) {
             const selectedTransition = (predicate || defaultPredicate)(
                 transitions,
@@ -316,7 +360,7 @@ export class UAStateMachineImplBase extends UAObjectImpl implements UAStateMachi
 
         if (typeof toStateNode === "string") {
             const state = this.getStateByName(toStateNode);
-            // c8 ignore next
+            /* c8 ignore next */
             if (!state) {
                 throw new Error(`Cannot find state with name ${toStateNode}`);
             }
@@ -590,6 +634,8 @@ export class UAStateMachineImplBase extends UAObjectImpl implements UAStateMachi
             throw new Error("cannot find FiniteStateMachineType");
         }
 
+        ensureFiniteStateMachineTypeGeneratesTransitionEvent(finiteStateMachineType);
+
         // xx assert(this.typeDefinitionObj && !this.subtypeOfObj);
         // xx assert(!this.typeDefinitionObj || this.typeDefinitionObj.isSubtypeOf(finiteStateMachineType));
         // get current Status

package/impl/state_machine/ua_shelving_state_machine_ex.ts

@@ -159,7 +159,7 @@ function _automatically_unshelve(shelvingState: UAShelvedStateMachineExImpl) {
     assert(shelvingState._timer, "expecting timerId to be set");
     shelvingState._timer = null;
 
-    // c8 ignore next
+    /* c8 ignore next */
     if (doDebug) {
         debugLog("Automatically un-shelving variable ", shelvingState.browseName.toString());
     }

package/impl/state_machine/ua_two_state_variable.ts

@@ -153,7 +153,7 @@ export function promoteToTwoStateVariable(node: UAVariable): UATwoStateVariableE
     if (node instanceof UATwoStateVariableImpl) {
         return node;
     }
-    // c8 ignore next
+    /* c8 ignore next */
     if (!(node instanceof UAVariableImpl)) {
         throw new Error("Trying to promote a invalid object");
     }

package/impl/tool_isSubtypeOf.ts

@@ -49,7 +49,7 @@ function _slow_isSubtypeOf<T extends UAType>(this: T, Class: typeof BaseNodeImpl
     for (const subType1 of subTypes) {
         const subTypeId = subType1.nodeId;
         const subTypeNode = this.addressSpace.findNode(subTypeId) as unknown as T;
-        // c8 ignore next
+        /* c8 ignore next */
         if (!subTypeNode) {
             throw new Error(`Cannot find object with nodeId ${subTypeId.toString()}`);
         }

package/impl/ua_data_type_impl.ts

@@ -9,7 +9,7 @@ import { DataTypeIds } from "node-opcua-constants";
 import { AttributeIds, type LocalizedText, NodeClass, type QualifiedNameLike } from "node-opcua-data-model";
 import { DataValue, type DataValueLike } from "node-opcua-data-value";
 import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
-import { ExpandedNodeId, NodeId, resolveNodeId } from "node-opcua-nodeid";
+import { ExpandedNodeId, NodeId, resolveNodeId, sameNodeId } from "node-opcua-nodeid";
 import { NumericRange } from "node-opcua-numeric-range";
 import { StatusCodes } from "node-opcua-status-code";
 import {
@@ -323,10 +323,31 @@ export class UADataTypeImpl extends BaseNodeImpl implements UADataType {
         const union = addressSpace.findDataType("Union");
 
         // we have a data type from a companion specification
-        // let's see if this data type need to be registered
-        const isEnumeration = enumeration && this.isSubtypeOf(enumeration);
-        const isStructure = structure && this.isSubtypeOf(structure);
-        const isUnion = !!(structure && union && this.isSubtypeOf(union));
+        // let's see if this data type need to be registered.
+        //
+        // One walk up the chain answers all three questions. `isSubtypeOf` would answer each of
+        // them, and memoizes — but its memo is keyed on a counter bumped every time a HasSubtype
+        // reference is added anywhere, so during a load, which adds thousands of them, the memo
+        // is thrown away before it is ever read and each call walks the chain from scratch. Three
+        // walks become one, and the one uses `subtypeOfObj`, which is cached per node, instead of
+        // filtering the node's whole reference list at every level.
+        let isEnumeration = false;
+        let isStructure = false;
+        let isUnion = false;
+        {
+            let ancestor: UADataTypeImpl | null = this;
+            // a chain longer than this is a cycle in a broken nodeset, not a model
+            let guard = 128;
+            while (ancestor && guard-- > 0) {
+                const nodeId = ancestor.nodeId;
+                if (enumeration && sameNodeId(nodeId, enumeration.nodeId)) isEnumeration = true;
+                if (structure && sameNodeId(nodeId, structure.nodeId)) isStructure = true;
+                if (union && sameNodeId(nodeId, union.nodeId)) isUnion = true;
+                ancestor = ancestor.subtypeOfObj as UADataTypeImpl | null;
+            }
+            // a Union is a Structure; the original asked for both and so does this
+            isUnion = isUnion && !!structure;
+        }
 
         const isRootDataType = (n: UADataType) => n.nodeId.namespace === 0 && n.nodeId.value === DataTypeIds.BaseDataType;
 

package/impl/ua_method_impl.ts

@@ -68,7 +68,10 @@ export class UAMethodImpl extends BaseNodeImpl<UAMethodEvents> implements UAMeth
     public methodDeclarationId: NodeId;
     public _getExecutableFlag?: (this: UAMethod, context: ISessionContext | null) => boolean;
 
-    public _asyncExecutionFunction?: MethodFunctor;
+    // always the callback form: bindMethod normalises the promise form before storing it. A union
+    // here would be wider than what can be held, and `.call` on a union of signatures does not
+    // resolve to the callback one.
+    public _asyncExecutionFunction?: MethodFunctorC;
 
     constructor(options: IMethodOptons) {
         super(options);
@@ -138,11 +141,12 @@ export class UAMethodImpl extends BaseNodeImpl<UAMethodEvents> implements UAMeth
 
     public bindMethod(async_func: MethodFunctor): void {
         assert(typeof async_func === "function");
-        if (async_func.length === 2) {
-            async_func = callbackify(async_func as MethodFunctorA) as MethodFunctorC;
-        }
-        assert(async_func.length === 3, ` a method with callback should have 3 arguments : got ${async_func.length}`);
-        this._asyncExecutionFunction = async_func;
+        const callbackForm: MethodFunctorC =
+            async_func.length === 2
+                ? (callbackify(async_func as MethodFunctorA) as MethodFunctorC)
+                : (async_func as MethodFunctorC);
+        assert(callbackForm.length === 3, ` a method with callback should have 3 arguments : got ${callbackForm.length}`);
+        this._asyncExecutionFunction = callbackForm;
     }
     public execute(
         object: UAObject | UAObjectType | null,

package/impl/ua_object_impl.ts

@@ -61,7 +61,7 @@ export class UAObjectImpl<T extends UAObjectEvents & ListenerSignature<T> = UAOb
     public readonly symbolicName: string | null;
 
     get typeDefinitionObj(): UAObjectType {
-        // c8 ignore next
+        /* c8 ignore next */
         if (super.typeDefinitionObj.nodeClass !== NodeClass.ObjectType) {
             const msg = `Invalid type definition node class , expecting a ObjectType got ${
                 NodeClass[super.typeDefinitionObj.nodeClass]
@@ -75,7 +75,11 @@ export class UAObjectImpl<T extends UAObjectEvents & ListenerSignature<T> = UAOb
     constructor(options: InternalBaseNodeOptions & { eventNotifier?: number; symbolicName?: string | null }) {
         super(options);
         this._eventNotifier = options.eventNotifier || EventNotifierFlags.None;
-        assert(typeof this.eventNotifier === "number" && isValidByte(this.eventNotifier));
+        // the declared flags, not the getter: reading the getter here scans the node's references
+        // for event sources and notifiers, twice, for a node that has just been built and whose
+        // references the loader has not wired yet. The getter answers the same value for a node in
+        // that state, and it still runs — and still caches — at the first real read.
+        assert(typeof this._eventNotifier === "number" && isValidByte(this._eventNotifier));
         this.symbolicName = options.symbolicName || null;
         // every event MonitoredItem on this object is one "event" listener, and the Server
         // object collects them for every Session: more than ten is the normal case, not a

package/impl/ua_variable_impl.ts

@@ -83,8 +83,9 @@ import { SessionContext } from "../api/session_context.js";
 import { apply_condition_refresh, type ConditionRefreshCache } from "./apply_condition_refresh.js";
 import { BaseNodeImpl, type InternalBaseNodeOptions } from "./base_node_impl.js";
 import { _clone, ToStringBuilder, UAVariable_toString, valueRankToString } from "./base_node_private.js";
+import { loadClock } from "./bulk_load_clock.js";
 import { adjustDataValueStatusCode } from "./data_access/adjust_datavalue_status_code.js";
-import { notifySemanticsChangedIfNeeded } from "./data_access/semantics_changed.js";
+import { notifySemanticsChangedIfNeeded, raiseSemanticChangeEvent } from "./data_access/semantics_changed.js";
 import { _getBasicDataType } from "./get_basic_datatype.js";
 import { type EnumerationInfo, type IEnumItem, UADataTypeImpl } from "./ua_data_type_impl.js";
 import {
@@ -254,7 +255,7 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
     public __waiting_callbacks?: CallbackT<DataValue>[];
 
     get typeDefinitionObj(): UAVariableType {
-        // c8 ignore next
+        /* c8 ignore next */
         if (super.typeDefinitionObj && super.typeDefinitionObj.nodeClass !== NodeClass.VariableType) {
             // this could happen in faulty external nodeset and has been seen once
             // in an nano server
@@ -288,8 +289,10 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
         // a Variant built from null takes the constructor's short path; the options form costs twice as much.
         // Stamped with the clock of the construction: a variable nobody gives a value to (a nodeset
         // Variable of an abstract data type has no default to make up) is read as it is, and the
-        // requested timestamps are expected on that Uncertain result too (FEAT-34)
-        const now = getCurrentClock();
+        // requested timestamps are expected on that Uncertain result too (FEAT-34).
+        // One reading for a whole load — see impl/bulk_load_clock.ts; outside a load of THIS
+        // address space this is getCurrentClock(), unchanged.
+        const now = loadClock(this.addressSpace);
         this.$dataValue = new DataValue({
             statusCode: StatusCodes.UncertainInitialValue,
             value: new Variant(null),
@@ -484,7 +487,7 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
             dataValue.statusCode.equals(StatusCodes.BadWaitingForInitialData) ||
             dataValue.statusCode.equals(StatusCodes.UncertainInitialValue)
         ) {
-            // c8 ignore next
+            /* c8 ignore next */
             doDebug &&
                 debugLog(
                     chalk.red(" Warning:  UAVariable#readValue ") +
@@ -846,7 +849,8 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
             if (variant1.dataType === DataType.ExtensionObject && !this.checkExtensionObjectIsCorrect(variant1.value)) {
                 throw new Error("invalid extension object");
             }
-            const now = getCurrentClock();
+            // the load's reading while this address space is being loaded, a fresh one otherwise
+            const now = loadClock(this.addressSpace);
             this.$dataValue = new DataValue({
                 value: variant1,
                 statusCode,
@@ -1883,13 +1887,13 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
 
         const addressSpace = this.addressSpace;
 
-        // c8 ignore next
+        /* c8 ignore next */
         if (!addressSpace) {
             warningLog("UAVariable#_internal_set_dataValue : no addressSpace ! may be node has already been deleted ?");
             return;
         }
 
-        // c8 ignore next
+        /* c8 ignore next */
         if (dataValue.value.arrayType === VariantArrayType.Matrix) {
             if (!dataValue.value.dimensions) {
                 throw new Error("missing dimensions: a Matrix Variant needs a dimension");
@@ -1997,6 +2001,9 @@ export class UAVariableImpl<T extends UAVariableEvents & ListenerSignature<T> =
     public handle_semantic_changed(_dataValue: DataValue): void {
         this.semantic_version = this.semantic_version + 1;
         (this as UAVariable).emit("semantic_changed");
+        // the bit tells whoever monitors this DataItem; the event tells whoever monitors the
+        // Server object (OPC 10000-5 6.4.31). Both have to come from this one place.
+        raiseSemanticChangeEvent(this as UAVariable);
     }
 
     private _readDataType(): DataValue {

package/impl/ua_variable_type_impl.ts

@@ -209,7 +209,7 @@ export class UAVariableTypeImpl extends BaseNodeImpl<BaseNodeEvents> implements
                     options.value = this.value as Variant;
                     options.statusCode = StatusCodes.Good;
                 } else {
-                    // c8 ignore next
+                    /* c8 ignore next */
                     doDebug && debugLog(" warning Value not implemented");
                     options.value = { dataType: DataType.Null };
                     options.statusCode = StatusCodes.BadAttributeIdInvalid;
@@ -277,7 +277,7 @@ export class UAVariableTypeImpl extends BaseNodeImpl<BaseNodeEvents> implements
         assertUnusedChildBrowseName(addressSpace, options);
 
         const baseVariableType = addressSpace.findVariableType("BaseVariableType");
-        // c8 ignore next
+        /* c8 ignore next */
         if (!baseVariableType) {
             throw new Error("BaseVariableType must be defined in the address space");
         }
@@ -298,7 +298,7 @@ export class UAVariableTypeImpl extends BaseNodeImpl<BaseNodeEvents> implements
 
         const arrayDimensions = options.arrayDimensions !== undefined ? options.arrayDimensions : this.arrayDimensions;
 
-        // c8 ignore next
+        /* c8 ignore next */
         if (!dataType || dataType.isEmpty()) {
             warningLog(" options.dataType", options.dataType ? options.dataType.toString() : "<null>");
             warningLog(" this.dataType", this.dataType ? this.dataType.toString() : "<null>");

package/nodeJS.d.ts

@@ -1 +1 @@
-export * from "./distNodeJS";
+export * from "./distNodeJS/index.js";

package/nodeJS.js

@@ -1 +1 @@
-module.exports = require("./distNodeJS");
+export * from "./distNodeJS/index.js";

package/package.json

@@ -1,6 +1,7 @@
 {
     "name": "node-opcua-address-space",
-    "version": "2.183.1",
+    "type": "module",
+    "version": "2.184.0",
     "description": "pure nodejs OPCUA SDK - module address-space",
     "main": "./dist/api/index.js",
     "types": "./dist/api/index.d.ts",
@@ -22,50 +23,50 @@
         "@types/semver": "7.8.0",
         "chalk": "4.1.2",
         "dequeue": "^1.0.5",
-        "node-opcua-address-space-base": "2.183.1",
-        "node-opcua-assert": "2.183.0",
-        "node-opcua-basic-types": "2.183.0",
-        "node-opcua-binary-stream": "2.183.0",
-        "node-opcua-client-dynamic-extension-object": "2.183.0",
-        "node-opcua-constants": "2.183.0",
+        "node-opcua-address-space-base": "2.184.0",
+        "node-opcua-assert": "2.184.0",
+        "node-opcua-basic-types": "2.184.0",
+        "node-opcua-binary-stream": "2.184.0",
+        "node-opcua-client-dynamic-extension-object": "2.184.0",
+        "node-opcua-constants": "2.184.0",
         "node-opcua-crypto": "5.10.1",
-        "node-opcua-data-access": "2.183.0",
-        "node-opcua-data-model": "2.183.0",
-        "node-opcua-data-value": "2.183.0",
-        "node-opcua-date-time": "2.183.0",
-        "node-opcua-debug": "2.183.0",
-        "node-opcua-enum": "2.183.0",
-        "node-opcua-extension-object": "2.183.0",
-        "node-opcua-factory": "2.183.0",
-        "node-opcua-nodeid": "2.183.0",
-        "node-opcua-nodeset-ua": "2.183.1",
-        "node-opcua-numeric-range": "2.183.0",
-        "node-opcua-object-registry": "2.183.0",
-        "node-opcua-pseudo-session": "2.183.0",
-        "node-opcua-service-browse": "2.183.0",
-        "node-opcua-service-call": "2.183.0",
-        "node-opcua-service-history": "2.183.0",
-        "node-opcua-service-translate-browse-path": "2.183.0",
-        "node-opcua-service-write": "2.183.0",
-        "node-opcua-status-code": "2.183.0",
-        "node-opcua-types": "2.183.0",
-        "node-opcua-utils": "2.183.0",
-        "node-opcua-variant": "2.183.0",
-        "node-opcua-xml2json": "2.183.0",
+        "node-opcua-data-access": "2.184.0",
+        "node-opcua-data-model": "2.184.0",
+        "node-opcua-data-value": "2.184.0",
+        "node-opcua-date-time": "2.184.0",
+        "node-opcua-debug": "2.184.0",
+        "node-opcua-enum": "2.184.0",
+        "node-opcua-extension-object": "2.184.0",
+        "node-opcua-factory": "2.184.0",
+        "node-opcua-nodeid": "2.184.0",
+        "node-opcua-nodeset-ua": "2.184.0",
+        "node-opcua-numeric-range": "2.184.0",
+        "node-opcua-object-registry": "2.184.0",
+        "node-opcua-pseudo-session": "2.184.0",
+        "node-opcua-service-browse": "2.184.0",
+        "node-opcua-service-call": "2.184.0",
+        "node-opcua-service-history": "2.184.0",
+        "node-opcua-service-translate-browse-path": "2.184.0",
+        "node-opcua-service-write": "2.184.0",
+        "node-opcua-status-code": "2.184.0",
+        "node-opcua-types": "2.184.0",
+        "node-opcua-utils": "2.184.0",
+        "node-opcua-variant": "2.184.0",
+        "node-opcua-xml2json": "2.184.0",
         "semver": "^7.8.5",
         "thenify-ex": "4.4.0",
         "xml-writer": "^1.7.0"
     },
     "devDependencies": {
         "humanize": "0.0.9",
-        "node-opcua-benchmarker": "2.183.0",
-        "node-opcua-leak-detector": "2.183.0",
-        "node-opcua-nodesets": "2.183.0",
-        "node-opcua-packet-analyzer": "2.183.0",
-        "node-opcua-schemas": "2.183.0",
-        "node-opcua-service-filter": "2.183.1",
-        "node-opcua-test-fixtures": "2.181.0",
-        "node-opcua-test-helpers": "2.183.0"
+        "node-opcua-benchmarker": "2.184.0",
+        "node-opcua-leak-detector": "2.184.0",
+        "node-opcua-nodesets": "2.184.0",
+        "node-opcua-packet-analyzer": "2.184.0",
+        "node-opcua-schemas": "2.184.0",
+        "node-opcua-service-filter": "2.184.0",
+        "node-opcua-test-fixtures": "2.184.0",
+        "node-opcua-test-helpers": "2.184.0"
     },
     "author": "Etienne Rossignon",
     "license": "MIT",
@@ -82,7 +83,7 @@
         "internet of things"
     ],
     "homepage": "http://node-opcua.github.io/",
-    "gitHead": "2326127b73f78cae1f0957788f16850a3be70701",
+    "gitHead": "441a5c63e3a4202eb8de8597acac77a3a49248b7",
     "files": [
         "dist",
         "distHelpers",
@@ -98,7 +99,7 @@
         "bin"
     ],
     "bin": {
-        "opcua-nodeset-image": "bin/opcua-nodeset-image.js",
-        "opcua-nodeset-live": "bin/opcua-nodeset-live.js"
+        "opcua-nodeset-image": "bin/opcua-nodeset-image.cjs",
+        "opcua-nodeset-live": "bin/opcua-nodeset-live.cjs"
     }
 }

package/source_nodejs/generate_address_space.ts

@@ -34,7 +34,7 @@ const debugLog = make_debugLog("generate_address_space");
 const errorLog = make_errorLog("generate_address_space");
 
 function checkNodeSet2XmlFileExists(xmlFile: string): void {
-    // c8 ignore next
+    /* c8 ignore next */
     if (!fs.existsSync(xmlFile)) {
         const msg = `[NODE-OPCUA-E02] generateAddressSpace : cannot find nodeset2 xml file at ${xmlFile}`;
         errorLog(msg);
@@ -101,11 +101,25 @@ export function siblingImageFileOf(xmlFile: string): string {
 /**
  * the sibling store: when `<file>.ndjson.gz` sits next to `<file>.xml` and its trailer digest is
  * the SHA-256 of the XML bytes, the image is what the loader gets; otherwise the XML is. The
- * digest check is not optional and not cached: an XML edited in place next to a stale image
- * loads from the XML. Nothing is written here; writing images is the opt-in `imageStore`.
+ * digest check is not cached: an XML edited in place next to a stale image loads from the XML.
+ * Nothing is written here; writing images is the opt-in `imageStore`.
  * Returns the source to load, and which path was taken for the debug log.
+ *
+ * `trustByLength` trades that guarantee for the cost of it. Validating an image means reading
+ * and hashing the whole XML — about 30 ms of the ~110 ms it takes to replay the standard
+ * nodeset, spent proving that a file nobody edited has not changed. With it, the recorded
+ * source length against the file size is the whole check, and the XML is never read at all.
+ * Every structural check on the image still runs; only the content digest is skipped.
+ *
+ * The risk it accepts is precise: an XML edited in place to exactly the same byte length, beside
+ * an image built from the earlier content, is replayed from the stale image. For the nodesets a
+ * package ships that cannot happen; for a file being edited it can, which is why this is off by
+ * default and why a loader that watches user files should leave it off.
  */
-async function siblingOrXml(xmlFile: string): Promise<{ source: NamedNodesetSource; path: "image" | "xml"; reason?: string }> {
+async function siblingOrXml(
+    xmlFile: string,
+    trustByLength = false
+): Promise<{ source: NamedNodesetSource; path: "image" | "xml"; reason?: string }> {
     checkNodeSet2XmlFileExists(xmlFile);
     // the XML is read only when it is going to be parsed or hashed; the image decision starts
     // with what costs nothing: its size
@@ -129,15 +143,21 @@ async function siblingOrXml(xmlFile: string): Promise<{ source: NamedNodesetSour
         // the inflate (zlib, off the main thread) and the hash of the XML (web crypto, off the
         // main thread too) run alongside; the digest is what decides, the length only rejects early
         const infoPending = readNodesetImageInfo(image);
-        const digestPending = readXml().then(sha256Hex);
-        digestPending.catch(() => undefined);
+        // not started at all when trusted by length: starting it is the cost being avoided
+        const digestPending = trustByLength ? undefined : readXml().then(sha256Hex);
+        digestPending?.catch(() => undefined);
         const info = await infoPending;
         const sourceLength = info.header.sourceLength;
-        if (sourceLength !== undefined && sourceLength !== fs.statSync(xmlFile).size) {
+        if (sourceLength === undefined) {
+            // nothing cheap to check it against, so a trusted read has no ground to stand on
+            if (trustByLength) return asXml("the image records no source length, so it cannot be trusted by length alone");
+        } else if (sourceLength !== fs.statSync(xmlFile).size) {
             return asXml(`the image is stale: it was built from ${sourceLength} bytes, the XML has ${fs.statSync(xmlFile).size}`);
         }
-        // a catalog package older or newer than this loader, a stale or truncated image: its XML is still right
-        const problem = nodesetImageProblem(info, await digestPending);
+        // a catalog package older or newer than this loader, a stale or truncated image: its XML
+        // is still right. Without a digest this still checks the schema, the trailer and the node
+        // count — `nodesetImageProblem` skips only the comparison it is not given.
+        const problem = nodesetImageProblem(info, digestPending ? await digestPending : undefined);
         if (problem) return asXml(problem);
     } catch (err) {
         return asXml(`the image cannot be read: ${(err as Error).message}`);
@@ -145,10 +165,7 @@ async function siblingOrXml(xmlFile: string): Promise<{ source: NamedNodesetSour
     return { source: { name: `${xmlFile} (image)`, source: image }, path: "image" };
 }
 
-// The one place this module learns where it sits on disk. `import.meta.dirname`
-// cannot be used while this package emits CommonJS (TS1470), so the ESM migration
-// has this single line to change rather than several scattered uses.
-const here = __dirname;
+const here = import.meta.dirname;
 
 /** the version this package was built as, for the header of the images it writes */
 export function addressSpacePackageVersion(): string {
@@ -197,7 +214,7 @@ export async function generateAddressSpace(
             sources.push(document);
             continue;
         }
-        const { source, path: taken, reason } = await siblingOrXml(document);
+        const { source, path: taken, reason } = await siblingOrXml(document, !!loaderOptions.trustSiblingImages);
         debugLog(`generateAddressSpace: ${path.basename(document)} from ${taken}${reason ? ` (${reason})` : ""}`);
         sources.push(source);
     }

package/testHelpers.d.ts

@@ -1 +1 @@
-export * from "./distHelpers";
+export * from "./distHelpers/index.js";

package/testHelpers.js

@@ -1 +1 @@
-module.exports = require("./distHelpers");
+export * from "./distHelpers/index.js";