node-opcua-address-space 2.183.1 → 2.184.0

package/api/helpers/adjust_browse_direction.ts

@@ -7,7 +7,7 @@ export function adjustBrowseDirection(
     browseDirection: BrowseDirection | null | undefined,
     defaultValue: BrowseDirection
 ): BrowseDirection {
-    // c8 ignore next
+    /* c8 ignore next */
     if (browseDirection === null || browseDirection === undefined) {
         return defaultValue;
     }

package/api/helpers/argument_list.ts

@@ -61,7 +61,7 @@ export function encode_ArgumentList(definition: ArgumentDef[], args: unknown[],
 }
 
 export function decode_ArgumentList(definition: ArgumentDef[], stream: BinaryStream): unknown[] {
-    // c8 ignore next
+    /* c8 ignore next */
     if (!Array.isArray(definition)) {
         throw new Error(
             "This BaseDataType cannot be decoded because it has no definition.\n" +
@@ -113,7 +113,7 @@ export function getMethodDeclaration_ArgumentList(
     // find object in address space
     const obj = addressSpace.findNode(objectId) as UAObject;
     if (!obj) {
-        // c8 ignore next
+        /* c8 ignore next */
         doDebug && debugLog("cannot find node ", objectId.toString());
 
         return { statusCode: StatusCodes.BadNodeIdUnknown };
@@ -135,7 +135,7 @@ export function getMethodDeclaration_ArgumentList(
         //  return {statusCode: StatusCodes.BadMethodInvalid};
         return { statusCode: StatusCodes.Good, methodDeclaration: objectMethod };
     }
-    // c8 ignore next
+    /* c8 ignore next */
     if (methodDeclaration.nodeClass !== NodeClass.Method) {
         throw new Error("Expecting a Method here");
     }
@@ -186,9 +186,9 @@ export function isArgumentValid(addressSpace: IAddressSpace, argDefinition: Argu
     const argDefDataType = addressSpace.findDataType(argDefinition.dataType);
     const argDataType = addressSpace.findDataType(resolveNodeId(arg.dataType));
 
-    // c8 ignore next
+    /* c8 ignore next */
     if (!argDefDataType) {
-        // c8 ignore next
+        /* c8 ignore next */
         doDebug && debugLog("dataType ", argDefinition.dataType.toString(), "doesn't exist");
         return false;
     }
@@ -202,7 +202,7 @@ export function isArgumentValid(addressSpace: IAddressSpace, argDefinition: Argu
         return false;
     }
 
-    // c8 ignore next
+    /* c8 ignore next */
     if (!argDataType) {
         doDebug && debugLog(" cannot find dataType ", arg.dataType, resolveNodeId(arg.dataType));
         doDebug && debugLog(" arg = ", arg.toString());
@@ -210,7 +210,7 @@ export function isArgumentValid(addressSpace: IAddressSpace, argDefinition: Argu
         return false;
     }
 
-    // c8 ignore next
+    /* c8 ignore next */
     if (doDebug) {
         doDebug && debugLog(" checking argDefDataType ", argDefDataType.toString());
         doDebug && debugLog(" checking argDataType ", argDataType.toString());
@@ -262,7 +262,7 @@ export function verifyArguments_ArgumentList(
     });
 
     if (methodInputArguments.length > inputArguments.length) {
-        // c8 ignore next
+        /* c8 ignore next */
         doDebug &&
             debugLog(
                 "verifyArguments_ArgumentList " +
@@ -278,7 +278,7 @@ export function verifyArguments_ArgumentList(
     }
 
     if (methodInputArguments.length < inputArguments.length) {
-        // c8 ignore next
+        /* c8 ignore next */
         doDebug &&
             debugLog(
                 " verifyArguments_ArgumentList " +

package/api/helpers/coerce_enum_value.ts

@@ -14,6 +14,7 @@ export function coerceEnumValues(enumValues: EnumValueTypeOptionsLike[] | { [key
             assert(Object.hasOwn(en, "value"));
             assert(Object.hasOwn(en, "displayName"));
             return new EnumValueType({
+                description: en.description !== undefined ? coerceLocalizedText(en.description) : null,
                 displayName: coerceLocalizedText(en.displayName),
                 value: coerceInt64(en.value || 0)
             });

package/api/helpers/dump_tools.ts

@@ -11,7 +11,7 @@ import { BrowseDescription, type BrowseDescriptionOptions, type ReferenceDescrip
 import { resolveReferenceType } from "../../impl/reference_impl.js";
 
 export function referenceTypeToString(addressSpace: IAddressSpace, referenceTypeId: NodeIdLike | null): string {
-    // c8 ignore next
+    /* c8 ignore next */
     if (!referenceTypeId) {
         return "<null> ";
     } else {

package/api/index.ts

@@ -98,8 +98,9 @@ export {
 } from "../impl/historical_access/read_processed_details_hook.js";
 /** @internal */
 export { isNonEmptyQualifiedName, NamespaceImpl } from "../impl/namespace_impl.js";
+export type { ConstructNodeIdOptions } from "../impl/nodeid_manager.js";
 /** How node ids are assigned within a namespace. */
-export { ConstructNodeIdOptions, NamespaceOptions, NodeIdManager } from "../impl/nodeid_manager.js";
+export { NamespaceOptions, NodeIdManager } from "../impl/nodeid_manager.js";
 /** Rewrites the server's namespace array to match the namespaces actually loaded. */
 export { adjustNamespaceArray } from "../impl/nodeset_tools/adjust_namespace_array.js";
 export * from "../impl/nodeset_tools/construct_namespace_dependency.js";

package/api/interfaces/data_access/ua_multistate_discrete_ex.ts

@@ -17,7 +17,7 @@ import type { DTEnumValue, UADiscreteItem, UADiscreteItem_Base, UAMultiStateDisc
 import type { StatusCode } from "node-opcua-status-code";
 import type { ISetStateOptions } from "../i_set_state_options.js";
 
-export { UAMultiStateDiscrete } from "node-opcua-nodeset-ua";
+export type { UAMultiStateDiscrete } from "node-opcua-nodeset-ua";
 
 export interface UAMultiStateDiscreteEx<T, DT extends DataType> extends UAVariableT<T, DT>, UAMultiStateDiscrete_Base<T, DT> {
     //------------ helpers ------------------

package/api/interfaces/nodeset_loader_options.ts

@@ -55,4 +55,21 @@ export interface NodeSetLoaderOptions {
      * @default undefined (no store)
      */
     imageStore?: NodesetImageStore | boolean;
+    /**
+     * accept a sibling `<name>.ndjson.gz` on the strength of the source length it records,
+     * without reading and hashing the XML to prove it.
+     *
+     * Validating a sibling image costs a read and a SHA-256 of the whole document — around
+     * 30 ms of the ~110 ms it takes to replay the standard nodeset, spent proving that a file
+     * nobody edited has not changed. This skips that: the recorded source length against the
+     * file size becomes the whole check, and the XML is never read. The image's schema, trailer
+     * and node count are still verified.
+     *
+     * What it gives up 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 — immutable, installed once — that cannot happen. For files a
+     * user edits it can, so leave this off there.
+     * @default false
+     */
+    trustSiblingImages?: boolean;
 }

package/api/loader/decode_xml_extension_object.ts

@@ -14,7 +14,7 @@ const _errorLog = make_errorLog("decode_xml_extension_object");
 function encodingNodeIdToDataTypeNode(addressSpace: IAddressSpace, encodingNodeId: NodeId): UADataType {
     const encodingNode = addressSpace.findNode(encodingNodeId);
 
-    // c8 ignore next
+    /* c8 ignore next */
     if (!encodingNode) {
         throw new Error(`findDataTypeNode:  Cannot find encoding NodeId${encodingNodeId.toString()}`);
     }

package/api/loader/ensure_datatype_extracted.ts

@@ -55,64 +55,100 @@ export async function ensureDatatypeExtracted(addressSpace: IAddressSpace): Prom
     const addressSpacePriv = addressSpace as AddressSpacePrivateWithDataTypeManager;
 
     if (!addressSpacePriv.$$extraDataTypeManager) {
-        const dataTypeManager = new ExtraDataTypeManager();
+        addressSpacePriv.$$extraDataTypeManager = new ExtraDataTypeManager();
+    }
+    const dataTypeManager = addressSpacePriv.$$extraDataTypeManager;
 
-        const namespaceArray = addressSpace.getNamespaceArray().map((n: INamespace) => n.namespaceUri);
+    const namespaceArray = addressSpace.getNamespaceArray().map((n: INamespace) => n.namespaceUri);
 
-        doDebug && debugLog("INamespace Array = ", namespaceArray.join("\n                   "));
+    doDebug && debugLog("INamespace Array = ", namespaceArray.join("\n                   "));
 
-        dataTypeManager.setNamespaceArray(namespaceArray);
+    dataTypeManager.setNamespaceArray(namespaceArray);
 
-        addressSpacePriv.$$extraDataTypeManager = dataTypeManager;
+    const factories: DataTypeFactory[] = [getStandardDataTypeFactory()];
 
-        const factories: DataTypeFactory[] = [getStandardDataTypeFactory()];
+    // A namespace with no factory is one this call has not seen yet: the first call sees them
+    // all, and a later one sees a namespace registered since, or one emptied by
+    // `deleteNamespace` and populated again - `deleteNamespace` drops that namespace's factory
+    // precisely so that its structures are extracted afresh rather than colliding with the
+    // schemas of the previous load. When every namespace already has one there is nothing to
+    // extract and this returns as fast as it always did.
+    let hasNewFactory = false;
 
-        const priorityTable = constructNamespacePriorityTable(addressSpace).priorityTable;
+    for (let namespaceIndex = 1; namespaceIndex < namespaceArray.length; namespaceIndex++) {
+        const namespace = addressSpace.getNamespace(namespaceIndex);
 
-        for (let namespaceIndex = 1; namespaceIndex < namespaceArray.length; namespaceIndex++) {
-            const namespace = addressSpace.getNamespace(namespaceIndex);
+        if (dataTypeManager.hasDataTypeFactory(namespaceIndex)) {
+            factories.push(dataTypeManager.getDataTypeFactory(namespaceIndex));
+            continue;
+        }
 
-            if (doDebug) {
-                debugLog("namespaceIndex = ", namespaceIndex);
-                debugLog("namespace = ", namespace.namespaceUri);
-                debugLog("factories = ", factories.map((f) => f.targetNamespace).join(" "));
-                // find dependent namespaces
-                let dependency = constructNamespaceDependency(namespace);
-                // remove last element that is my namespace
-                dependency = dependency.filter((ns) => ns.index !== namespaceIndex);
-                const dependFactories = dependency.map((ns) => {
-                    const df = factories[ns.index];
-                    if (!df) {
-                        debugLog("namespaceIndex = ", namespaceIndex);
-                        debugLog("namespace = ", namespace.namespaceUri);
-                        debugLog("priorityTable", priorityTable);
-                        debugLog(dependency.map((ns) => `${ns.index} ${ns.namespaceUri}`).join("\n"));
-                        throw new Error(`Cannot find factory for namespace ${ns.namespaceUri}`);
-                    }
-                    return df;
-                });
-                //            getStandardDataTypeFactory()
+        // NOTE: a DataTypeFactory chains POSITIONALLY — to every factory built
+        // before it, not to the namespaces it actually depends on. That over-couples
+        // namespaces, and it matters now that `deleteNamespace` exists: dropping a
+        // namespace leaves everything loaded after it holding a discarded factory,
+        // so the factory, its schemas and its ExtensionObject constructors stay
+        // alive. A consumer that registers its own namespace BEFORE its dependencies
+        // is chained through by every one of them, and leaks a factory per reload.
+        //
+        // The dependency-correct computation exists below, under `if (doDebug)`,
+        // with its result assigned to a variable nobody reads. Using it is NOT a
+        // drop-in: `constructNamespaceDependency` walks values and throws on an
+        // ExtensionObject with a null schema (`construct_namespace_dependency.ts`,
+        // `exploreExtensionObject`). Being debug-only, it has never had to survive
+        // the hot path — calling it on every load breaks server writes with
+        // `TypeError: Cannot read properties of null (reading 'schema')`.
+        //
+        // So the fix is two changes, not one: harden that walk, then switch the
+        // chain. Deliberately left for its own change, with its own tests, rather
+        // than smuggled into this one.
+        if (doDebug) {
+            const priorityTable = constructNamespacePriorityTable(addressSpace).priorityTable;
+            debugLog("namespaceIndex = ", namespaceIndex);
+            debugLog("namespace = ", namespace.namespaceUri);
+            debugLog("factories = ", factories.map((f) => f.targetNamespace).join(" "));
+            // find dependent namespaces
+            let dependency = constructNamespaceDependency(namespace);
+            // remove last element that is my namespace
+            dependency = dependency.filter((ns) => ns.index !== namespaceIndex);
+            const dependFactories = dependency.map((ns) => {
+                const df = factories[ns.index];
+                if (!df) {
+                    debugLog("namespaceIndex = ", namespaceIndex);
+                    debugLog("namespace = ", namespace.namespaceUri);
+                    debugLog("priorityTable", priorityTable);
+                    debugLog(dependency.map((ns) => `${ns.index} ${ns.namespaceUri}`).join("\n"));
+                    throw new Error(`Cannot find factory for namespace ${ns.namespaceUri}`);
+                }
+                return df;
+            });
+            //            getStandardDataTypeFactory()
+
+            const _dataTypeFactory1 = new DataTypeFactory(dependFactories);
+        }
+        const dataTypeFactory1 = new DataTypeFactory([...factories]);
+        dataTypeFactory1.targetNamespace = namespace.namespaceUri;
 
-                const _dataTypeFactory1 = new DataTypeFactory(dependFactories);
-            }
-            const dataTypeFactory1 = new DataTypeFactory([...factories]);
-            dataTypeFactory1.targetNamespace = namespace.namespaceUri;
+        factories.push(dataTypeFactory1);
 
-            factories.push(dataTypeFactory1);
+        dataTypeManager.registerDataTypeFactory(namespaceIndex, dataTypeFactory1);
+        hasNewFactory = true;
+    }
 
-            dataTypeManager.registerDataTypeFactory(namespaceIndex, dataTypeFactory1);
-        }
+    if (hasNewFactory) {
         // inject simple types
 
         // now extract structure and enumeration from old form
         const session = new PseudoSession(addressSpace);
 
+        // the extraction skips a dataType whose factory already knows it, so the namespaces that
+        // were extracted by an earlier call are walked but not rebuilt
         await populateDataTypeManager(session, dataTypeManager, DataTypeExtractStrategy.Auto);
 
         // turn old <=103 structure to have valid DataTypeDefinition
         fixDefinition103(addressSpace, namespaceArray, dataTypeManager);
     }
-    return addressSpacePriv.$$extraDataTypeManager as ExtraDataTypeManager;
+    return dataTypeManager;
 }
 
 export function ensureDatatypeExtractedWithCallback(addressSpace: IAddressSpace, callback: CallbackT<ExtraDataTypeManager>): void {

package/api/loader/generateAddressSpaceRaw.ts

@@ -2,6 +2,7 @@ import type { IAddressSpace, RequiredModel } from "node-opcua-address-space-base
 import { checkDebugFlag, make_debugLog, make_errorLog } from "node-opcua-debug";
 import type { CallbackT } from "node-opcua-status-code";
 import semver from "semver";
+import { beginBulkLoadClock, endBulkLoadClock } from "../../impl/bulk_load_clock.js";
 import type { NamespacePrivate } from "../../impl/namespace_private.js";
 import { adjustNamespaceArray } from "../../impl/nodeset_tools/adjust_namespace_array.js";
 import type { NodeSetLoaderOptions } from "../interfaces/nodeset_loader_options.js";
@@ -341,32 +342,41 @@ export async function generateAddressSpaceRaw(
         }
     }
 
-    for (let index = 0; index < order.length; index++) {
-        const nodesetIndex = order[index];
-        const nodeset = nodesetDesc[nodesetIndex];
-        // c8 ignore next
-        doDebug && debugLog(" loading ", nodesetIndex, nodeset.reader.name);
-        try {
-            if (nodeset.format.name === NDJSON_IMAGE_FORMAT) {
-                // an image is already the cache: replaying it through the cache would be storing
-                // a copy of what was just read
-                try {
-                    await nodesetLoader.addRecords(nodeset.format.records(nodeset.document));
-                } finally {
-                    releaseInflatedImageLines(await nodeset.document.rawBytes());
+    // Everything this load creates is stamped with ONE clock reading rather than one apiece:
+    // see impl/bulk_load_clock.ts. Scoped to this address space and reference counted, so a
+    // load of another address space, or a write to one that is not loading, is unaffected.
+    // `finally` matters: a load that throws must not leave the clock frozen.
+    beginBulkLoadClock(addressSpace);
+    try {
+        for (let index = 0; index < order.length; index++) {
+            const nodesetIndex = order[index];
+            const nodeset = nodesetDesc[nodesetIndex];
+            // c8 ignore next
+            doDebug && debugLog(" loading ", nodesetIndex, nodeset.reader.name);
+            try {
+                if (nodeset.format.name === NDJSON_IMAGE_FORMAT) {
+                    // an image is already the cache: replaying it through the cache would be storing
+                    // a copy of what was just read
+                    try {
+                        await nodesetLoader.addRecords(nodeset.format.records(nodeset.document));
+                    } finally {
+                        releaseInflatedImageLines(await nodeset.document.rawBytes());
+                    }
+                } else {
+                    await loadThroughCache(nodesetLoader, nodeset.format, nodeset.document, nodeset.reader, store);
                 }
-            } else {
-                await loadThroughCache(nodesetLoader, nodeset.format, nodeset.document, nodeset.reader, store);
+            } catch (err) {
+                const cause = err instanceof Error ? err.message : String(err);
+                const message = `generateAddressSpace: loading nodeset ${nodeset.reader.name} failed: ${cause}`;
+                errorLog(message);
+                throw new Error(message, { cause: err });
             }
-        } catch (err) {
-            const cause = err instanceof Error ? err.message : String(err);
-            const message = `generateAddressSpace: loading nodeset ${nodeset.reader.name} failed: ${cause}`;
-            errorLog(message);
-            throw new Error(message, { cause: err });
         }
-    }
 
-    await nodesetLoader.terminate();
+        await nodesetLoader.terminate();
+    } finally {
+        endBulkLoadClock(addressSpace);
+    }
     adjustNamespaceArray(addressSpace);
     // however process them in series
 }

package/api/loader/load_nodeset2.ts

@@ -177,7 +177,7 @@ export class NodeSetLoader {
                 dataType: DataType.String,
                 value: addressSpace1.getNamespaceArray().map((ns) => ns.namespaceUri)
             });
-            // c8 ignore next
+            /* c8 ignore next */
             if (doDebug) {
                 debugLog(
                     "addressSpace NS = ",
@@ -208,7 +208,7 @@ export class NodeSetLoader {
                 try {
                     await task(addressSpace1);
                 } catch (err) {
-                    // c8 ignore next
+                    /* c8 ignore next */
                     if (types.isNativeError(err)) {
                         errorLog(
                             `[NODE-OPCUA-W36] generateAddressSpace: post-loading task failed during "${stage}" and was skipped: ${err.message}`

package/api/loader/namespace_post_step.ts

@@ -40,7 +40,7 @@ export async function promoteObjectAndVariablesInNamespace(namespace: INamespace
 
                 promoter.promoter(a as UAVariable & UAObject);
                 const after = a.constructor.name;
-                // c8 ignore next
+                /* c8 ignore next */
                 if (doDebug) {
                     debugLog(`promoting ${a.browseName.toString()} from ${before} to ${after}`);
                 }

package/api/loader/narrow_instance_datatypes.ts

@@ -50,7 +50,13 @@ function typeDefinitionOf(addressSpace: IAddressSpace, node: UAInstance): UAType
  * walks the chain once per member
  */
 class DeclarationIndex {
-    private readonly cache = new Map<string, BaseNode | null>();
+    /**
+     * per type, the answer for each browse name asked of it. Keyed on the type node itself
+     * rather than on a `${nodeId}|${browseName}` string: a sweep asks this thousands of times,
+     * and building that key rendered a NodeId to text, rendered a QualifiedName to text and
+     * joined them — on every hit as much as on every miss.
+     */
+    private readonly cache = new Map<BaseNode, Map<string, BaseNode | null>>();
     /** absent from a standard nodeset older than 1.04: then no type has interfaces to look into */
     private readonly hasInterface: UAReferenceType | null;
     private readonly hasModellingRule: UAReferenceType;
@@ -76,22 +82,29 @@ class DeclarationIndex {
     }
 
     public find(type: UAType, browseName: QualifiedName): BaseNode | null {
-        const key = `${type.nodeId.toString()}|${browseName.toString()}`;
-        const cached = this.cache.get(key);
+        let perType = this.cache.get(type);
+        if (!perType) {
+            perType = new Map<string, BaseNode | null>();
+            this.cache.set(type, perType);
+        }
+        // the browse name still needs a key, but only the one string, and only on a miss for
+        // this type; `toString` renders the namespace index with it, so two names that differ
+        // only by namespace do not collide
+        const key = browseName.toString();
+        const cached = perType.get(key);
         if (cached !== undefined) {
             return cached;
         }
-        const found = this.walk(type, browseName, new Set<string>());
-        this.cache.set(key, found);
+        const found = this.walk(type, browseName, new Set<BaseNode>());
+        perType.set(key, found);
         return found;
     }
 
-    private walk(type: UAType, browseName: QualifiedName, visited: Set<string>): BaseNode | null {
-        const typeKey = type.nodeId.toString();
-        if (visited.has(typeKey)) {
+    private walk(type: UAType, browseName: QualifiedName, visited: Set<BaseNode>): BaseNode | null {
+        if (visited.has(type)) {
             return null;
         }
-        visited.add(typeKey);
+        visited.add(type);
         const child = type.getChildByName(browseName);
         if (child) {
             return child;

package/api/loader/nodeset_image_codec.ts

@@ -588,6 +588,8 @@ const OPTIONAL_PLAIN: Array<keyof NodesetNodeRecord & keyof NodesetImageNode> =
     "accessLevel",
     "userAccessLevel"
 ];
+/** the same keys, for the reader, which asks of a key the image carries whether it is one of these */
+const OPTIONAL_PLAIN_SET = new Set<string>(OPTIONAL_PLAIN);
 
 export function encodeNode(record: NodesetNodeRecord): NodesetImageNode {
     const out: NodesetImageNode = {
@@ -650,24 +652,36 @@ export function decodeNode(json: NodesetImageNode): NodesetNodeRecord {
     if (typeof json.nodeClass !== "number" || !(json.nodeClass in NodeClass)) {
         throw new NodesetImageError(`not a node record: ${JSON.stringify(json).slice(0, 80)}`);
     }
+    // a sized array filled in place: a nodeset carries twenty thousand references, and `map` over
+    // the encoded ones allocated a closure per node and grew the array as it went
+    const encoded = json.references || [];
+    const references: NodesetReferenceRecord[] = new Array(encoded.length);
+    for (let i = 0; i < encoded.length; i++) {
+        const r = encoded[i];
+        references[i] = {
+            isForward: r[0] === 1,
+            referenceType: decodeNodeId(r[1]),
+            nodeId: decodeNodeId(r[2]),
+            inverseDeclared: r.length === 3
+        };
+    }
     const record: NodesetNodeRecord = {
         kind: "node",
         nodeClass: json.nodeClass,
         nodeId: decodeNodeId(json.nodeId),
         browseName: decodeQualifiedName(json.browseName),
-        references: (json.references || []).map(
-            (r): NodesetReferenceRecord => ({
-                isForward: r[0] === 1,
-                referenceType: decodeNodeId(r[1]),
-                nodeId: decodeNodeId(r[2]),
-                inverseDeclared: r.length === 3
-            })
-        )
+        references
     };
-    for (const key of OPTIONAL_PLAIN) {
-        const v = (json as unknown as Record<string, unknown>)[key];
-        if (v !== undefined) {
-            (record as unknown as Record<string, unknown>)[key] = v;
+    // the keys the writer actually emitted, not the nineteen it might have: a node carries a
+    // handful of them, and probing for each of the nineteen was most of this loop's work
+    const plain = json as unknown as Record<string, unknown>;
+    const out = record as unknown as Record<string, unknown>;
+    for (const key in plain) {
+        if (OPTIONAL_PLAIN_SET.has(key)) {
+            const v = plain[key];
+            if (v !== undefined) {
+                out[key] = v;
+            }
         }
     }
     // an absent displayName is the browse name: what the writer left out because it was the same

package/api/loader/nodeset_record_applier.ts

@@ -289,7 +289,7 @@ export class NodesetRecordApplier implements NodesetRecordConsumer {
             }
             found.add(namespaceUri);
             const namespace = this.addressSpace.getNamespace(namespaceUri);
-            // c8 ignore next
+            /* c8 ignore next */
             if (!namespace) {
                 throw new Error(
                     `cannot find namespace for ${namespaceUri}\nplease make sure to initialize your address space with the corresponding nodeset files`

package/api/loader/nodeset_xml_producer.ts

@@ -58,14 +58,12 @@ export function makeXmlNodesetRecordReader(): XmlNodesetRecordReader {
     const models: NodesetModelRecord[] = [];
     const aliases: Record<string, NodeId> = Object.create(null);
     let headerEmitted = false;
-    // every id string of the file resolved once: "i=47" alone appears tens of thousands of times
+    // every id string of the file resolved once: "i=47" alone appears tens of thousands of times.
+    // The aliases are seeded into the same table as they are declared — an alias is just another
+    // spelling of an id — so the fifty thousand lookups a document costs are one probe, not two.
     const ids = new Map<string, NodeId>();
 
     function nodeIdOf(text: string): NodeId {
-        const alias = aliases[text];
-        if (alias) {
-            return alias;
-        }
         let nodeId = ids.get(text);
         if (!nodeId) {
             nodeId = resolveNodeId(text);
@@ -108,7 +106,11 @@ export function makeXmlNodesetRecordReader(): XmlNodesetRecordReader {
 
     const state_Alias = {
         finish(this: State) {
-            aliases[this.attrs.Alias] = resolveNodeId(this.text);
+            const name = this.attrs.Alias;
+            const nodeId = resolveNodeId(this.text);
+            aliases[name] = nodeId;
+            // the alias table still travels in the header record; the id table is what nodeIdOf reads
+            ids.set(name, nodeId);
         }
     };
 

package/api/loader/parsers/extension_object_parser.ts

@@ -313,12 +313,12 @@ export function makeExtensionObjectParser<T>(
                                 }
                                 break;
                             default: {
-                                // c8 ignore next
+                                /* c8 ignore next */
                                 if (!this._cloneFragment) {
                                     // the XML file is probably not exposing standard UA extension object correctly.
                                     // this has been seen in some generated xml files using the dataType nodeId instead of the default encoding
                                     // nodeid
-                                    // c8 ignore next
+                                    /* c8 ignore next */
                                     doDebug &&
                                         errorLog(
                                             "[NODE-OPCUA-E12] standard OPCUA Extension object from (namespace=0) has a invalid TypeId",
@@ -332,7 +332,7 @@ export function makeExtensionObjectParser<T>(
                                 // the "Default Xml" encoding  nodeId
                                 const xmlEncodingNodeId = typeDefinitionId;
                                 if (typeDefinitionId.isEmpty()) {
-                                    // c8 ignore next
+                                    /* c8 ignore next */
                                     doDebug && debugLog(`xmlEncodingNodeId is empty for ${typeDefinitionId.toString()}`);
                                     break;
                                 }

package/api/pseudo_session.ts

@@ -62,7 +62,7 @@ export function innerBrowse(
         // handle continuation points
         results = results.map((result: BrowseResult, _index) => {
             assert(!result.continuationPoint);
-            // c8 ignore next
+            /* c8 ignore next */
             if (!engine.continuationPointManager) {
                 return new BrowseResult({ statusCode: StatusCodes.BadNoContinuationPoints });
             }

package/bin/{nodeset_equivalence.js → nodeset_equivalence.cjs}

@@ -73,7 +73,7 @@ const {
     xmlNodesetRecords
 } = require("../dist/api/index.js");
 const { digestAddressSpace } = require("../distNodeJS/index.js");
-const { asFile, dependencyChain } = require("./nodeset_tool_common.js");
+const { asFile, dependencyChain } = require("./nodeset_tool_common.cjs");
 
 const usage = () => {
     console.error("usage: opcua-nodeset-live equivalence <file.xml>... [--require <file.xml>]... [--dump <dir>] [--quiet]");

package/bin/{opcua-nodeset-image.js → opcua-nodeset-image.cjs}

@@ -27,7 +27,7 @@ const path = require("node:path");
 const { performance } = require("node:perf_hooks");
 const { readNodesetImageInfo, recordsToNodeset2XML } = require("../dist/api/index.js");
 const { nodesetFileToImage } = require("../distNodeJS/index.js");
-const { imageFileOf, kb, recordsOfFile } = require("./nodeset_tool_common.js");
+const { imageFileOf, kb, recordsOfFile } = require("./nodeset_tool_common.cjs");
 
 const usage = () => {
     console.error("usage: opcua-nodeset-image build   <file.xml>... [--out <dir>]");

package/bin/{opcua-nodeset-live.js → opcua-nodeset-live.cjs}

@@ -31,8 +31,8 @@ const {
     nodesetFileToImage,
     readNodeSet2XmlFile
 } = require("../distNodeJS/index.js");
-const { asFile, dependencyChain, imageFileOf, kb } = require("./nodeset_tool_common.js");
-const { equivalence } = require("./nodeset_equivalence.js");
+const { asFile, dependencyChain, imageFileOf, kb } = require("./nodeset_tool_common.cjs");
+const { equivalence } = require("./nodeset_equivalence.cjs");
 
 const usage = () => {
     console.error("usage: opcua-nodeset-live verify      <file.xml>... [--require <file.xml>]...");

package/dist/api/address_space_public.d.ts

@@ -55,3 +55,4 @@ export interface AddressSpaceConstructor {
  * checked rather than asserted.
  */
 export declare const AddressSpace: AddressSpaceConstructor;
+//# sourceMappingURL=address_space_public.d.ts.map

package/dist/api/address_space_public.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"address_space_public.d.ts","sourceRoot":"","sources":["../../api/address_space_public.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAEnE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD;;;;;GAKG;AACH,MAAM,WAAW,YAAa,SAAQ,aAAa;IAC/C,eAAe,IAAI,SAAS,CAAC;IAC7B,iBAAiB,CAAC,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IACnD,UAAU,EAAE,YAAY,CAAC;IAEzB;;;;;;;OAOG;IACH,0BAA0B,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;CAC3D;AAED;;;;;;GAMG;AACH,MAAM,WAAW,uBAAuB;IACpC,mCAAmC;IACnC,MAAM,IAAI,YAAY,CAAC;IAEvB;;;OAGG;IACH,iBAAiB,CAAC,EAAE,kBAAkB,CAAC;CAC1C;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY,EAAE,uBAA0C,CAAC"}