node-opcua-address-space-for-conformance-testing 2.180.0 → 2.181.1

package/dist/address_space_for_conformance_testing.d.ts

@@ -4,7 +4,17 @@
  * Builds the conformance-testing address space by delegating to focused sub-modules.
  */
 import type { AddressSpace } from "node-opcua-address-space";
-export declare function build_address_space_for_conformance_testing(addressSpace: AddressSpace, options?: {
+import { type CustomExtensionObjectOptions } from "./conformance_testing/custom_extension_object.js";
+export type { CustomExtensionObjectOptions } from "./conformance_testing/custom_extension_object.js";
+export interface BuildAddressSpaceForConformanceTestingOptions {
     mass_variable?: boolean;
     mass_variables?: boolean;
-}): Promise<void>;
+    /**
+     * The concrete structure the ExtensionObject variables hold. Namespace zero
+     * has none worth exercising, so a caller that has loaded a companion nodeset
+     * passes one in; without it those variables keep a null ExtensionObject.
+     * See ./conformance_testing/custom_extension_object.ts.
+     */
+    extensionObject?: CustomExtensionObjectOptions;
+}
+export declare function build_address_space_for_conformance_testing(addressSpace: AddressSpace, options?: BuildAddressSpaceForConformanceTestingOptions): Promise<void>;

package/dist/address_space_for_conformance_testing.js

@@ -2,28 +2,31 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.build_address_space_for_conformance_testing = build_address_space_for_conformance_testing;
 const testHelpers_1 = require("node-opcua-address-space/testHelpers");
-const access_right_variables_1 = require("./conformance_testing/access_right_variables");
-const analog_data_items_1 = require("./conformance_testing/analog_data_items");
-const discrete_variables_1 = require("./conformance_testing/discrete_variables");
-const enumeration_variable_1 = require("./conformance_testing/enumeration_variable");
-const mass_variables_1 = require("./conformance_testing/mass_variables");
-const node_with_references_1 = require("./conformance_testing/node_with_references");
-const object_with_methods_1 = require("./conformance_testing/object_with_methods");
-const path_and_large_arrays_1 = require("./conformance_testing/path_and_large_arrays");
-const sample_view_1 = require("./conformance_testing/sample_view");
-const simulation_variables_1 = require("./conformance_testing/simulation_variables");
-const static_variables_1 = require("./conformance_testing/static_variables");
-const trigger_nodes_1 = require("./conformance_testing/trigger_nodes");
+const access_right_variables_js_1 = require("./conformance_testing/access_right_variables.js");
+const analog_data_items_js_1 = require("./conformance_testing/analog_data_items.js");
+const ctt_folder_js_1 = require("./conformance_testing/ctt_folder.js");
+const custom_extension_object_js_1 = require("./conformance_testing/custom_extension_object.js");
+const discrete_variables_js_1 = require("./conformance_testing/discrete_variables.js");
+const enumeration_variable_js_1 = require("./conformance_testing/enumeration_variable.js");
+const mass_variables_js_1 = require("./conformance_testing/mass_variables.js");
+const node_with_references_js_1 = require("./conformance_testing/node_with_references.js");
+const object_with_methods_js_1 = require("./conformance_testing/object_with_methods.js");
+const path_and_large_arrays_js_1 = require("./conformance_testing/path_and_large_arrays.js");
+const sample_view_js_1 = require("./conformance_testing/sample_view.js");
+const simulation_variables_js_1 = require("./conformance_testing/simulation_variables.js");
+const static_variables_js_1 = require("./conformance_testing/static_variables.js");
+const trigger_nodes_js_1 = require("./conformance_testing/trigger_nodes.js");
 async function build_address_space_for_conformance_testing(addressSpace, options) {
     const namespace = addressSpace.registerNamespace("urn://node-opcua-simulator");
     options = options || {};
     options.mass_variable = options.mass_variable || false;
+    const custom = (0, custom_extension_object_js_1.resolveCustomExtensionObject)(addressSpace, options.extensionObject);
     const objectsFolder = addressSpace.findNode("ObjectsFolder");
     const simulationFolder = namespace.addFolder(objectsFolder, {
         browseName: "Simulation",
         nodeId: "s=SimulationFolder"
     });
-    (0, access_right_variables_1.addAccessRightVariables)(namespace, simulationFolder);
+    (0, access_right_variables_js_1.addAccessRightVariables)(namespace, simulationFolder);
     const staticVariablesFolder = namespace.addFolder(simulationFolder, {
         browseName: "Static"
     });
@@ -31,25 +34,27 @@ async function build_address_space_for_conformance_testing(addressSpace, options
         browseName: "All Profiles"
     });
     // Scalars/Array/MultiDim array of all sorts
-    await (0, static_variables_1.addStaticVariables)(namespace, allProfileFolder);
+    await (0, static_variables_js_1.addStaticVariables)(namespace, allProfileFolder, custom);
     if (options.mass_variables) {
-        (0, mass_variables_1.addMassVariables)(namespace, allProfileFolder);
+        (0, mass_variables_js_1.addMassVariables)(namespace, allProfileFolder, custom);
     }
-    (0, analog_data_items_1.addAnalogDataItems)(namespace, allProfileFolder);
+    (0, analog_data_items_js_1.addAnalogDataItems)(namespace, allProfileFolder);
     const dynamicVariablesFolder = namespace.addFolder(simulationFolder, {
         browseName: "Dynamic"
     });
-    (0, simulation_variables_1.addSimulationVariables)(namespace, dynamicVariablesFolder);
-    (0, path_and_large_arrays_1.addVeryLargeArrayVariables)(namespace, staticVariablesFolder);
-    (0, path_and_large_arrays_1.addPath10Deep)(namespace, simulationFolder);
-    (0, node_with_references_1.addNodeWithReferences)(namespace, simulationFolder);
-    (0, object_with_methods_1.addObjectWithMethod)(namespace, simulationFolder);
+    (0, simulation_variables_js_1.addSimulationVariables)(namespace, dynamicVariablesFolder, custom);
+    (0, path_and_large_arrays_js_1.addVeryLargeArrayVariables)(namespace, staticVariablesFolder, custom);
+    (0, path_and_large_arrays_js_1.addPath10Deep)(namespace, simulationFolder);
+    (0, node_with_references_js_1.addNodeWithReferences)(namespace, simulationFolder);
+    (0, object_with_methods_js_1.addObjectWithMethod)(namespace, simulationFolder);
     (0, testHelpers_1.add_eventGeneratorObject)(namespace, simulationFolder);
-    (0, sample_view_1.addSampleView)(namespace);
-    (0, enumeration_variable_1.addEnumerationVariable)(namespace, simulationFolder);
-    (0, discrete_variables_1.addMultiStateValueDiscreteVariables)(namespace, simulationFolder);
-    (0, discrete_variables_1.addTwoStateDiscreteVariables)(namespace, simulationFolder);
-    (0, discrete_variables_1.addMultiStateDiscreteVariable)(namespace, simulationFolder);
-    (0, trigger_nodes_1.addTriggerNodes)(namespace, simulationFolder);
+    (0, sample_view_js_1.addSampleView)(namespace);
+    (0, enumeration_variable_js_1.addEnumerationVariable)(namespace, simulationFolder);
+    (0, discrete_variables_js_1.addMultiStateValueDiscreteVariables)(namespace, simulationFolder);
+    (0, discrete_variables_js_1.addTwoStateDiscreteVariables)(namespace, simulationFolder);
+    (0, discrete_variables_js_1.addMultiStateDiscreteVariable)(namespace, simulationFolder);
+    (0, trigger_nodes_js_1.addTriggerNodes)(namespace, simulationFolder);
+    // nodes named after the CTT settings the folders above do not serve
+    (0, ctt_folder_js_1.addCttFolder)(namespace, objectsFolder);
 }
 //# sourceMappingURL=address_space_for_conformance_testing.js.map

package/dist/address_space_for_conformance_testing.js.map

@@ -1 +1 @@
-{"version":3,"file":"address_space_for_conformance_testing.js","sourceRoot":"","sources":["../src/address_space_for_conformance_testing.ts"],"names":[],"mappings":";;AAyBA,kGA4DC;AA/ED,sEAAgF;AAEhF,yFAAuF;AACvF,+EAA6E;AAC7E,iFAIkD;AAClD,qFAAoF;AACpF,yEAAwE;AACxE,qFAAmF;AACnF,mFAAgF;AAChF,uFAAwG;AACxG,mEAAkE;AAClE,qFAAoF;AACpF,6EAA4E;AAC5E,uEAAsE;AAE/D,KAAK,UAAU,2CAA2C,CAC7D,YAA0B,EAC1B,OAA+D;IAE/D,MAAM,SAAS,GAAG,YAAY,CAAC,iBAAiB,CAAC,4BAA4B,CAAC,CAAC;IAE/E,OAAO,GAAG,OAAO,IAAI,EAAE,CAAC;IACxB,OAAO,CAAC,aAAa,GAAG,OAAO,CAAC,aAAa,IAAI,KAAK,CAAC;IAEvD,MAAM,aAAa,GAAG,YAAY,CAAC,QAAQ,CAAC,eAAe,CAAa,CAAC;IAEzE,MAAM,gBAAgB,GAAG,SAAS,CAAC,SAAS,CAAC,aAAa,EAAE;QACxD,UAAU,EAAE,YAAY;QACxB,MAAM,EAAE,oBAAoB;KAC/B,CAAC,CAAC;IAEH,IAAA,gDAAuB,EAAC,SAAS,EAAE,gBAAgB,CAAC,CAAC;IAErD,MAAM,qBAAqB,GAAG,SAAS,CAAC,SAAS,CAAC,gBAAgB,EAAE;QAChE,UAAU,EAAE,QAAQ;KACvB,CAAC,CAAC;IAEH,MAAM,gBAAgB,GAAG,SAAS,CAAC,SAAS,CAAC,qBAAqB,EAAE;QAChE,UAAU,EAAE,cAAc;KAC7B,CAAC,CAAC;IAEH,4CAA4C;IAC5C,MAAM,IAAA,qCAAkB,EAAC,SAAS,EAAE,gBAAgB,CAAC,CAAC;IAEtD,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC;QACzB,IAAA,iCAAgB,EAAC,SAAS,EAAE,gBAAgB,CAAC,CAAC;IAClD,CAAC;IACD,IAAA,sCAAkB,EAAC,SAAS,EAAE,gBAAgB,CAAC,CAAC;IAEhD,MAAM,sBAAsB,GAAG,SAAS,CAAC,SAAS,CAAC,gBAAgB,EAAE;QACjE,UAAU,EAAE,SAAS;KACxB,CAAC,CAAC;IACH,IAAA,6CAAsB,EAAC,SAAS,EAAE,sBAAsB,CAAC,CAAC;IAE1D,IAAA,kDAA0B,EAAC,SAAS,EAAE,qBAAqB,CAAC,CAAC;IAE7D,IAAA,qCAAa,EAAC,SAAS,EAAE,gBAAgB,CAAC,CAAC;IAE3C,IAAA,4CAAqB,EAAC,SAAS,EAAE,gBAAgB,CAAC,CAAC;IAEnD,IAAA,yCAAmB,EAAC,SAAS,EAAE,gBAAgB,CAAC,CAAC;IAEjD,IAAA,sCAAwB,EAAC,SAAS,EAAE,gBAAgB,CAAC,CAAC;IAEtD,IAAA,2BAAa,EAAC,SAAS,CAAC,CAAC;IAEzB,IAAA,6CAAsB,EAAC,SAAS,EAAE,gBAAgB,CAAC,CAAC;IAEpD,IAAA,wDAAmC,EAAC,SAAS,EAAE,gBAAgB,CAAC,CAAC;IAEjE,IAAA,iDAA4B,EAAC,SAAS,EAAE,gBAAgB,CAAC,CAAC;IAE1D,IAAA,kDAA6B,EAAC,SAAS,EAAE,gBAAgB,CAAC,CAAC;IAE3D,IAAA,+BAAe,EAAC,SAAS,EAAE,gBAAgB,CAAC,CAAC;AACjD,CAAC"}
+{"version":3,"file":"address_space_for_conformance_testing.js","sourceRoot":"","sources":["../src/address_space_for_conformance_testing.ts"],"names":[],"mappings":";;AAwCA,kGAgEC;AAlGD,sEAAgF;AAChF,+FAA0F;AAC1F,qFAAgF;AAChF,uEAAmE;AACnE,iGAAmI;AACnI,uFAIqD;AACrD,2FAAuF;AACvF,+EAA2E;AAC3E,2FAAsF;AACtF,yFAAmF;AACnF,6FAA2G;AAC3G,yEAAqE;AACrE,2FAAuF;AACvF,mFAA+E;AAC/E,6EAAyE;AAgBlE,KAAK,UAAU,2CAA2C,CAC7D,YAA0B,EAC1B,OAAuD;IAEvD,MAAM,SAAS,GAAG,YAAY,CAAC,iBAAiB,CAAC,4BAA4B,CAAC,CAAC;IAE/E,OAAO,GAAG,OAAO,IAAI,EAAE,CAAC;IACxB,OAAO,CAAC,aAAa,GAAG,OAAO,CAAC,aAAa,IAAI,KAAK,CAAC;IACvD,MAAM,MAAM,GAAG,IAAA,yDAA4B,EAAC,YAAY,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC;IAEnF,MAAM,aAAa,GAAG,YAAY,CAAC,QAAQ,CAAC,eAAe,CAAa,CAAC;IAEzE,MAAM,gBAAgB,GAAG,SAAS,CAAC,SAAS,CAAC,aAAa,EAAE;QACxD,UAAU,EAAE,YAAY;QACxB,MAAM,EAAE,oBAAoB;KAC/B,CAAC,CAAC;IAEH,IAAA,mDAAuB,EAAC,SAAS,EAAE,gBAAgB,CAAC,CAAC;IAErD,MAAM,qBAAqB,GAAG,SAAS,CAAC,SAAS,CAAC,gBAAgB,EAAE;QAChE,UAAU,EAAE,QAAQ;KACvB,CAAC,CAAC;IAEH,MAAM,gBAAgB,GAAG,SAAS,CAAC,SAAS,CAAC,qBAAqB,EAAE;QAChE,UAAU,EAAE,cAAc;KAC7B,CAAC,CAAC;IAEH,4CAA4C;IAC5C,MAAM,IAAA,wCAAkB,EAAC,SAAS,EAAE,gBAAgB,EAAE,MAAM,CAAC,CAAC;IAE9D,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC;QACzB,IAAA,oCAAgB,EAAC,SAAS,EAAE,gBAAgB,EAAE,MAAM,CAAC,CAAC;IAC1D,CAAC;IACD,IAAA,yCAAkB,EAAC,SAAS,EAAE,gBAAgB,CAAC,CAAC;IAEhD,MAAM,sBAAsB,GAAG,SAAS,CAAC,SAAS,CAAC,gBAAgB,EAAE;QACjE,UAAU,EAAE,SAAS;KACxB,CAAC,CAAC;IACH,IAAA,gDAAsB,EAAC,SAAS,EAAE,sBAAsB,EAAE,MAAM,CAAC,CAAC;IAElE,IAAA,qDAA0B,EAAC,SAAS,EAAE,qBAAqB,EAAE,MAAM,CAAC,CAAC;IAErE,IAAA,wCAAa,EAAC,SAAS,EAAE,gBAAgB,CAAC,CAAC;IAE3C,IAAA,+CAAqB,EAAC,SAAS,EAAE,gBAAgB,CAAC,CAAC;IAEnD,IAAA,4CAAmB,EAAC,SAAS,EAAE,gBAAgB,CAAC,CAAC;IAEjD,IAAA,sCAAwB,EAAC,SAAS,EAAE,gBAAgB,CAAC,CAAC;IAEtD,IAAA,8BAAa,EAAC,SAAS,CAAC,CAAC;IAEzB,IAAA,gDAAsB,EAAC,SAAS,EAAE,gBAAgB,CAAC,CAAC;IAEpD,IAAA,2DAAmC,EAAC,SAAS,EAAE,gBAAgB,CAAC,CAAC;IAEjE,IAAA,oDAA4B,EAAC,SAAS,EAAE,gBAAgB,CAAC,CAAC;IAE1D,IAAA,qDAA6B,EAAC,SAAS,EAAE,gBAAgB,CAAC,CAAC;IAE3D,IAAA,kCAAe,EAAC,SAAS,EAAE,gBAAgB,CAAC,CAAC;IAE7C,oEAAoE;IACpE,IAAA,4BAAY,EAAC,SAAS,EAAE,aAAa,CAAC,CAAC;AAC3C,CAAC"}

package/dist/conformance_testing/alarm_input_nodes.d.ts

@@ -0,0 +1,2 @@
+import type { CttFolder } from "./ctt_tree.js";
+export declare function addAlarmInputNodes(ctt: CttFolder): void;

package/dist/conformance_testing/alarm_input_nodes.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addAlarmInputNodes = addAlarmInputNodes;
+const node_opcua_variant_1 = require("node-opcua-variant");
+/** where the CTT keeps these settings; outside "Server Test/NodeIds", so the whole path is the key */
+const GROUP = "Server Test/Alarms and Conditions/Supported Condition Types";
+/** the limits every limit-derived alarm here is given, in the units of a 0..100 input */
+const LIMITS = { lowLowLimit: 10, lowLimit: 25, highLimit: 75, highHighLimit: 90 };
+const double = (value) => new node_opcua_variant_1.Variant({ dataType: node_opcua_variant_1.DataType.Double, value });
+const boolean = (value) => new node_opcua_variant_1.Variant({ dataType: node_opcua_variant_1.DataType.Boolean, value });
+/**
+ * The object every alarm is a condition of. It must be an event source of
+ * something, or `conditionSource` throws; making it an event source of the
+ * Server object is what puts its events on the Server notifier the CTT
+ * subscribes to.
+ */
+function addAlarmSource(ctt) {
+    const server = ctt.addressSpace.rootFolder.objects.server;
+    return ctt.namespace.addObject({
+        browseName: "AlarmSource",
+        nodeId: ctt.nodeId("Server Test/Alarms and Conditions/AlarmSource"),
+        organizedBy: ctt.folder("Server Test/Alarms and Conditions"),
+        description: "condition source of the CTT alarm input nodes",
+        eventSourceOf: server
+    });
+}
+function addAlarmInputNodes(ctt) {
+    const namespace = ctt.namespace;
+    const conditionSource = addAlarmSource(ctt);
+    /** the writable Variable a CTT alarm setting points at; 50 sits inside LIMITS, so alarms start inactive */
+    const inputNode = (leaf, kind) => ctt.variable(`${GROUP}/${leaf}`, kind, -1, kind === "Double" ? double(50) : boolean(false), null);
+    /** a deviation setpoint, at 0 so the deviation the alarm evaluates is the input value itself */
+    const setpointNode = (leaf) => ctt.variable(`${GROUP}/${leaf}`, "Double", -1, double(0), null);
+    const alarmOptions = (browseName, input) => ({
+        browseName,
+        nodeId: ctt.nodeId(`Server Test/Alarms and Conditions/${browseName}`),
+        conditionSource,
+        inputNode: input
+    });
+    // ── AlarmConditionType ──────────────────────────────────────────────
+    // the base type has no sub-state model: the CTT drives ActiveState itself
+    namespace.instantiateAlarmCondition("AlarmConditionType", alarmOptions("AlarmCondition", inputNode("AlarmConditionType Input Nodes", "Double")));
+    // ── the limit family ────────────────────────────────────────────────
+    namespace.instantiateLimitAlarm("LimitAlarmType", {
+        ...alarmOptions("LimitAlarm", inputNode("LimitAlarmType Input Nodes", "Double")),
+        ...LIMITS
+    });
+    for (const [typeName, leaf] of [
+        ["ExclusiveLimitAlarmType", "ExclusiveLimitAlarmType Input Nodes"],
+        ["ExclusiveLevelAlarmType", "ExclusiveLevelAlarmType Input Nodes"],
+        ["ExclusiveRateOfChangeAlarmType", "ExclusiveRateOfChangeAlarmType Input Nodes"]
+    ]) {
+        namespace.instantiateExclusiveLimitAlarm(typeName, {
+            ...alarmOptions(typeName.replace(/Type$/, ""), inputNode(leaf, "Double")),
+            ...LIMITS
+        });
+    }
+    for (const [typeName, leaf] of [
+        ["NonExclusiveLimitAlarmType", "NonExclusiveLimitAlarmType Input Nodes"],
+        ["NonExclusiveLevelAlarmType", "NonExclusiveLevelAlarmType Input Nodes"],
+        ["NonExclusiveRateOfChangeAlarmType", "NonExclusiveRateOfChangeAlarmType Input Nodes"]
+    ]) {
+        namespace.instantiateNonExclusiveLimitAlarm(typeName, {
+            ...alarmOptions(typeName.replace(/Type$/, ""), inputNode(leaf, "Double")),
+            ...LIMITS
+        });
+    }
+    // ── the deviation pairs: the setpoint is a setting of its own ───────
+    const exclusiveSetpoint = setpointNode("Exclusive Deviation Setpoint Source");
+    namespace.instantiateExclusiveDeviationAlarm({
+        ...alarmOptions("ExclusiveDeviationAlarm", inputNode("ExclusiveDeviationAlarmType Input Nodes", "Double")),
+        ...LIMITS,
+        setpointNode: exclusiveSetpoint
+    });
+    const nonExclusiveSetpoint = setpointNode("NonExclusive Deviation Setpoint Source");
+    namespace.instantiateNonExclusiveDeviationAlarm({
+        ...alarmOptions("NonExclusiveDeviationAlarm", inputNode("NonExclusiveDeviationAlarmType Input Nodes", "Double")),
+        ...LIMITS,
+        setpointNode: nonExclusiveSetpoint
+    });
+    // ── the discrete family ─────────────────────────────────────────────
+    namespace.instantiateDiscreteAlarm("DiscreteAlarmType", alarmOptions("DiscreteAlarm", inputNode("DiscreteAlarmType Input Nodes", "Boolean")));
+    // OffNormalAlarmType is active while its input differs from NormalState
+    const normalState = namespace.addVariable({
+        browseName: "OffNormalNormalState",
+        nodeId: ctt.nodeId("Server Test/Alarms and Conditions/OffNormalNormalState"),
+        componentOf: ctt.folder("Server Test/Alarms and Conditions"),
+        description: "the value OffNormalAlarmType considers normal",
+        dataType: "Boolean",
+        value: boolean(false)
+    });
+    namespace.instantiateOffNormalAlarm({
+        ...alarmOptions("OffNormalAlarm", inputNode("OffNormalAlarmType Input Nodes", "Boolean")),
+        normalState
+    });
+    // `instantiateOffNormalAlarm` is hardwired to OffNormalAlarmType and
+    // UASystemOffNormalAlarmImpl is not exported, so the derived type is
+    // instantiated generically: the node and its mandatory children exist,
+    // the NormalState comparison is not wired.
+    namespace.instantiateAlarmCondition("SystemOffNormalAlarmType", alarmOptions("SystemOffNormalAlarm", inputNode("SystemOffNormalAlarmType Input Nodes", "Boolean")));
+}
+//# sourceMappingURL=alarm_input_nodes.js.map

package/dist/conformance_testing/alarm_input_nodes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"alarm_input_nodes.js","sourceRoot":"","sources":["../../src/conformance_testing/alarm_input_nodes.ts"],"names":[],"mappings":"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"}

package/dist/conformance_testing/ctt_folder.d.ts

@@ -0,0 +1,2 @@
+import type { Namespace, UAObject } from "node-opcua-address-space";
+export declare function addCttFolder(namespace: Namespace, objectsFolder: UAObject): UAObject;

package/dist/conformance_testing/ctt_folder.js

@@ -0,0 +1,375 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addCttFolder = addCttFolder;
+/**
+ * The `CTT` folder: nodes named after the settings of the OPC Foundation
+ * Compliance Test Tool (UACTT) server project.
+ *
+ * The browse path below Objects/CTT mirrors the setting path below
+ * "Server Test/NodeIds", e.g. the setting
+ *   Server Test/NodeIds/Static/HA Profile/Arrays/Int162D
+ * is served by
+ *   Objects/CTT/Static/HA Profile/Arrays/Int162D   (NodeId s=CTT/Static/HA Profile/Arrays/Int162D)
+ * so a CTT project generator can fill the setting by browsing, without any
+ * hand-maintained map. See ./ctt_tree.ts for how a setting outside that prefix
+ * is keyed. Only settings the rest of this address space does not already serve
+ * are built here - plus the two Bool settings, see addBooleanScalarAndArray().
+ *
+ * Not covered, and why:
+ *   Decimal                             deprecated in OPC UA 1.05
+ *   the HA Aggregates nodes             need node-opcua-aggregates and a seeded
+ *                                       history matching the CTT's StartOfBadData*
+ *   NodeDoesNotSupportServerTimestamp   needs the variable read path to omit it
+ *   NodeManagement/RootNode             the server has no AddNodes service
+ *   Chattering Alarms                   needs an alarm that flips state on its own
+ *   DiscrepancyAlarmType Input Nodes    see ./alarm_input_nodes.ts
+ */
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_opcua_data_access_1 = require("node-opcua-data-access");
+const node_opcua_data_model_1 = require("node-opcua-data-model");
+const node_opcua_variant_1 = require("node-opcua-variant");
+const alarm_input_nodes_js_1 = require("./alarm_input_nodes.js");
+const ctt_tree_js_1 = require("./ctt_tree.js");
+// ─── Static / All Profiles ──────────────────────────────────────────────
+function addVariantVariables(ctt) {
+    // "Variant" in CTT terms: a Variable whose DataType attribute is BaseDataType
+    const scalar = new node_opcua_variant_1.Variant({ dataType: node_opcua_variant_1.DataType.Double, value: 3.14 });
+    ctt.variable("Static/All Profiles/Scalar/Variant", "BaseDataType", -1, scalar, null);
+    // The array is the one case the CTT actually type-checks: Attribute Read 023.js
+    // asserts AssertUaValueOfType(BuiltInType.Variant, ...) against this node, so the
+    // *value* has to be Variant-encoded (BuiltInType 24), not merely stored on a
+    // BaseDataType-typed Variable. A Float64Array reads back as Double (11) and fails
+    // that assertion. Mixed element types are also the point of the type, and exercise
+    // the encoder the way the test intends.
+    ctt.variable("Static/All Profiles/Arrays/Variant", "BaseDataType", 1, new node_opcua_variant_1.Variant({
+        dataType: node_opcua_variant_1.DataType.Variant,
+        arrayType: node_opcua_variant_1.VariantArrayType.Array,
+        value: [
+            new node_opcua_variant_1.Variant({ dataType: node_opcua_variant_1.DataType.Double, value: 1 }),
+            new node_opcua_variant_1.Variant({ dataType: node_opcua_variant_1.DataType.UInt32, value: 2 }),
+            new node_opcua_variant_1.Variant({ dataType: node_opcua_variant_1.DataType.String, value: "three" }),
+            new node_opcua_variant_1.Variant({ dataType: node_opcua_variant_1.DataType.Boolean, value: true }),
+            new node_opcua_variant_1.Variant({ dataType: node_opcua_variant_1.DataType.Float, value: 5.5 })
+        ]
+    }), [5]);
+    ctt.variable("Static/All Profiles/Multi-Dimensional-Arrays/Variant", "BaseDataType", 2, new node_opcua_variant_1.Variant({
+        dataType: node_opcua_variant_1.DataType.Double,
+        arrayType: node_opcua_variant_1.VariantArrayType.Matrix,
+        dimensions: [2, 3],
+        value: new Float64Array([1, 2, 3, 4, 5, 6])
+    }), [2, 3]);
+}
+/**
+ * `Static/All Profiles/Scalar/Bool` and `.../Arrays/Bool`, which the Simulation
+ * folder would otherwise serve.
+ *
+ * A generator resolves a setting by overlay, then convention, then the CTT's own
+ * default, then by *browse name*, then by rule. The HA Profile nodes below are
+ * browse-named after their setting leaf, so `Static/HA Profile/Scalar/Bool` is
+ * literally named `Bool` - and the name step matches it against the All Profiles
+ * `Bool` settings, for which there is no convention node, while the Simulation
+ * node named `Boolean` matches neither. The name step runs before the rule step,
+ * so those two settings would silently resolve to a historizing node. Every other
+ * type name is safe: `Byte`, `Double` and the rest match both nodes and the rule
+ * scoring then prefers the non-historizing one.
+ *
+ * Building the two nodes here makes the convention step answer first, which is
+ * both deterministic and where the CTT-specific extras belong - hence the two
+ * Description properties, which View Minimum Continuation Point 01 012 needs
+ * (it browses the Scalar/Bool setting node with a NodeClassMask of Variable and
+ * wants at least two such references).
+ */
+function addBooleanScalarAndArray(ctt) {
+    const scalar = ctt.typedVariable("Static/All Profiles/Scalar/Bool", "Boolean", -1);
+    for (const name of ["Description1", "Description2"]) {
+        ctt.namespace.addVariable({
+            propertyOf: scalar,
+            browseName: name,
+            nodeId: ctt.nodeId(`Static/All Profiles/Scalar/Bool/${name}`),
+            dataType: "String",
+            value: new node_opcua_variant_1.Variant({ dataType: node_opcua_variant_1.DataType.String, value: `${name} of the static Boolean` })
+        });
+    }
+    ctt.typedVariable("Static/All Profiles/Arrays/Bool", "Boolean", 1);
+}
+function addImageVariable(ctt) {
+    // the abstract Image data type (the concrete ImagePNG/GIF/JPG/BMP nodes live under Simulation)
+    let png;
+    try {
+        png = node_fs_1.default.readFileSync(node_path_1.default.join(__dirname, "../../data", "tux.png"));
+    }
+    catch (_err) {
+        png = Buffer.from("89504e470d0a1a0a", "hex");
+    }
+    ctt.variable("Static/All Profiles/Scalar/Image", "Image", -1, new node_opcua_variant_1.Variant({ dataType: node_opcua_variant_1.DataType.ByteString, value: png }), null);
+}
+function addStructureVariables(ctt) {
+    const addressSpace = ctt.addressSpace;
+    const structures = [
+        { dataType: "Range", fields: { low: -10, high: 10 } },
+        {
+            dataType: "EUInformation",
+            fields: {
+                namespaceUri: "http://www.opcfoundation.org/UA/units/un/cefact",
+                unitId: 4408652,
+                displayName: { text: "°C" },
+                description: { text: "degree Celsius" }
+            }
+        },
+        { dataType: "TimeZoneDataType", fields: { offset: 60, daylightSavingInOffset: false } },
+        {
+            dataType: "EnumValueType",
+            fields: { value: [1, 0], displayName: { text: "One" }, description: { text: "the value one" } }
+        },
+        {
+            dataType: "Argument",
+            fields: {
+                name: "arg",
+                dataType: "i=6",
+                valueRank: -1,
+                arrayDimensions: null,
+                description: { text: "an Int32 argument" }
+            }
+        }
+    ];
+    structures.forEach((s, i) => {
+        const dataTypeNode = addressSpace.findDataType(s.dataType);
+        if (!dataTypeNode)
+            throw new Error(`DataType ${s.dataType} not found`);
+        const value = addressSpace.constructExtensionObject(dataTypeNode, s.fields);
+        ctt.variable(`Static/All Profiles/Structures/Structure${String(i + 1).padStart(3, "0")}`, s.dataType, -1, new node_opcua_variant_1.Variant({ dataType: node_opcua_variant_1.DataType.ExtensionObject, value }), null);
+    });
+}
+// ─── Static / DA Profile ────────────────────────────────────────────────
+function addAnalogItemArrays(ctt) {
+    const folder = ctt.folder("Static/DA Profile/AnalogItemType Arrays");
+    for (const dataTypeName of ["Double", "Float", "Int16", "Int32", "UInt16", "UInt32"]) {
+        const dataType = node_opcua_variant_1.DataType[dataTypeName];
+        ctt.namespace.addAnalogDataItem({
+            organizedBy: folder,
+            browseName: dataTypeName,
+            nodeId: ctt.nodeId(`Static/DA Profile/AnalogItemType Arrays/${dataTypeName}`),
+            dataType: dataTypeName,
+            valueRank: 1,
+            arrayDimensions: [5],
+            arrayType: node_opcua_variant_1.VariantArrayType.Array,
+            engineeringUnitsRange: { low: -100, high: 100 },
+            instrumentRange: { low: -1000, high: 1000 },
+            engineeringUnits: node_opcua_data_access_1.standardUnits.degree_celsius,
+            value: new node_opcua_variant_1.Variant({ dataType, arrayType: node_opcua_variant_1.VariantArrayType.Array, value: (0, node_opcua_variant_1.buildVariantArray)(dataType, 5, 0) }),
+            accessLevel: ctt_tree_js_1.readWrite,
+            userAccessLevel: ctt_tree_js_1.readWrite
+        });
+    }
+}
+function axis(addressSpace, title, low, high) {
+    const axisInformation = addressSpace.findDataType("AxisInformation");
+    if (!axisInformation)
+        throw new Error("AxisInformation not found");
+    return addressSpace.constructExtensionObject(axisInformation, {
+        engineeringUnits: node_opcua_data_access_1.standardUnits.second,
+        euRange: { low, high },
+        title: { text: title },
+        axisScaleType: 0, // Linear
+        axisSteps: null
+    });
+}
+/**
+ * The five ArrayItemType subtypes: plain variables of the right VariableType,
+ * given the mandatory ArrayItemType properties by hand. instantiate() refuses
+ * a ValueRank that differs from the type's (ImageItemType and CubeItemType
+ * need 2 and 3) and namespace.addYArrayItem() ignores nodeId and organizedBy.
+ */
+function addArrayItems(ctt) {
+    const addressSpace = ctt.addressSpace;
+    const namespace = ctt.namespace;
+    const group = "Static/DA Profile/ArrayItemType";
+    const folder = ctt.folder(group);
+    const xAxis = axis(addressSpace, "x", 0, 10);
+    const yAxis = axis(addressSpace, "y", 0, 20);
+    const zAxis = axis(addressSpace, "z", 0, 30);
+    const rangeType = addressSpace.findDataType("Range");
+    const xvType = addressSpace.findDataType("XVType");
+    if (!rangeType || !xvType)
+        throw new Error("Range or XVType not found");
+    const extensionObject = (value) => new node_opcua_variant_1.Variant({ dataType: node_opcua_variant_1.DataType.ExtensionObject, value });
+    const arrayItem = (typeName, options, axes) => {
+        const v = namespace.addVariable({
+            organizedBy: folder,
+            browseName: typeName,
+            nodeId: ctt.nodeId(`${group}/${typeName}`),
+            typeDefinition: typeName,
+            dataType: options.dataType,
+            valueRank: options.valueRank,
+            arrayDimensions: options.arrayDimensions,
+            accessLevel: ctt_tree_js_1.readWrite,
+            userAccessLevel: ctt_tree_js_1.readWrite,
+            value: options.value
+        });
+        const property = (browseName, dataType, value, valueRank = -1) => namespace.addVariable({ propertyOf: v, browseName, dataType, valueRank, value, modellingRule: "Mandatory" });
+        property("Title", "LocalizedText", new node_opcua_variant_1.Variant({ dataType: node_opcua_variant_1.DataType.LocalizedText, value: { text: typeName } }));
+        property("AxisScaleType", "AxisScaleEnumeration", new node_opcua_variant_1.Variant({ dataType: node_opcua_variant_1.DataType.Int32, value: 0 }));
+        property("EURange", "Range", extensionObject(addressSpace.constructExtensionObject(rangeType, { low: 0, high: 100 })));
+        property("InstrumentRange", "Range", extensionObject(addressSpace.constructExtensionObject(rangeType, { low: 0, high: 1000 })));
+        property("EngineeringUnits", "EUInformation", extensionObject(node_opcua_data_access_1.standardUnits.degree_celsius));
+        for (const [name, value] of Object.entries(axes)) {
+            property(name, "AxisInformation", value, value.arrayType === node_opcua_variant_1.VariantArrayType.Array ? 1 : -1);
+        }
+        return v;
+    };
+    arrayItem("YArrayItemType", {
+        dataType: "Double",
+        valueRank: 1,
+        arrayDimensions: [5],
+        value: new node_opcua_variant_1.Variant({
+            dataType: node_opcua_variant_1.DataType.Double,
+            arrayType: node_opcua_variant_1.VariantArrayType.Array,
+            value: new Float64Array([1, 2, 3, 4, 5])
+        })
+    }, { XAxisDefinition: extensionObject(xAxis) });
+    arrayItem("XYArrayItemType", {
+        dataType: "XVType",
+        valueRank: 1,
+        arrayDimensions: [3],
+        value: new node_opcua_variant_1.Variant({
+            dataType: node_opcua_variant_1.DataType.ExtensionObject,
+            arrayType: node_opcua_variant_1.VariantArrayType.Array,
+            value: [0, 1, 2].map((i) => addressSpace.constructExtensionObject(xvType, { x: i, value: i * 2 }))
+        })
+    }, { XAxisDefinition: extensionObject(xAxis) });
+    arrayItem("ImageItemType", {
+        dataType: "UInt16",
+        valueRank: 2,
+        arrayDimensions: [2, 3],
+        value: new node_opcua_variant_1.Variant({
+            dataType: node_opcua_variant_1.DataType.UInt16,
+            arrayType: node_opcua_variant_1.VariantArrayType.Matrix,
+            dimensions: [2, 3],
+            value: new Uint16Array([1, 2, 3, 4, 5, 6])
+        })
+    }, { XAxisDefinition: extensionObject(xAxis), YAxisDefinition: extensionObject(yAxis) });
+    arrayItem("CubeItemType", {
+        dataType: "Double",
+        valueRank: 3,
+        arrayDimensions: [2, 2, 2],
+        value: new node_opcua_variant_1.Variant({
+            dataType: node_opcua_variant_1.DataType.Double,
+            arrayType: node_opcua_variant_1.VariantArrayType.Matrix,
+            dimensions: [2, 2, 2],
+            value: new Float64Array([1, 2, 3, 4, 5, 6, 7, 8])
+        })
+    }, {
+        XAxisDefinition: extensionObject(xAxis),
+        YAxisDefinition: extensionObject(yAxis),
+        ZAxisDefinition: extensionObject(zAxis)
+    });
+    arrayItem("NDimensionArrayItemType", {
+        dataType: "Double",
+        valueRank: 2,
+        arrayDimensions: [2, 3],
+        value: new node_opcua_variant_1.Variant({
+            dataType: node_opcua_variant_1.DataType.Double,
+            arrayType: node_opcua_variant_1.VariantArrayType.Matrix,
+            dimensions: [2, 3],
+            value: new Float64Array([1, 2, 3, 4, 5, 6])
+        })
+    }, {
+        AxisDefinition: new node_opcua_variant_1.Variant({
+            dataType: node_opcua_variant_1.DataType.ExtensionObject,
+            arrayType: node_opcua_variant_1.VariantArrayType.Array,
+            value: [xAxis, yAxis]
+        })
+    });
+}
+// ─── Static / HA Profile ────────────────────────────────────────────────
+const HA_TYPES = [
+    "Bool",
+    "Byte",
+    "ByteString",
+    "DateTime",
+    "Double",
+    "Float",
+    "Int16",
+    "Int32",
+    "Int64",
+    "SByte",
+    "String",
+    "UInt16",
+    "UInt32",
+    "UInt64",
+    "XmlElement"
+];
+/** a variable with in-memory history and a first value, so reads are Good with timestamps */
+function historize(ctt, variable) {
+    ctt.addressSpace.installHistoricalDataNode(variable);
+    const current = variable.readValue().value;
+    variable.setValueFromSource(current);
+    return variable;
+}
+function addHistorizingVariables(ctt) {
+    for (const leaf of HA_TYPES) {
+        const dataTypeName = ctt_tree_js_1.TYPE_ALIAS[leaf] ?? leaf;
+        historize(ctt, ctt.typedVariable(`Static/HA Profile/Scalar/${leaf}`, dataTypeName, -1));
+        historize(ctt, ctt.typedVariable(`Static/HA Profile/Arrays/${leaf}`, dataTypeName, 1));
+        historize(ctt, ctt.typedVariable(`Static/HA Profile/Arrays/${leaf}2D`, dataTypeName, 2));
+    }
+    const range = ctt.addressSpace.findDataType("Range");
+    if (!range)
+        throw new Error("Range not found");
+    historize(ctt, ctt.variable("Static/HA Profile/StructureNodeSupportingHistory", "Range", -1, new node_opcua_variant_1.Variant({
+        dataType: node_opcua_variant_1.DataType.ExtensionObject,
+        value: ctt.addressSpace.constructExtensionObject(range, { low: 0, high: 1 })
+    }), null));
+    // AccessLevel_* : the AccessLevel attribute; UserAccessLevel_* : the UserAccessLevel attribute
+    const history = node_opcua_data_model_1.AccessLevelFlag.HistoryRead;
+    const flags = {
+        ReadOnly: node_opcua_data_model_1.AccessLevelFlag.CurrentRead | history,
+        WriteOnly: node_opcua_data_model_1.AccessLevelFlag.CurrentWrite | history,
+        None: history
+    };
+    for (const attribute of ["AccessLevel", "UserAccessLevel"]) {
+        for (const [kind, flag] of Object.entries(flags)) {
+            const relPath = `Static/HA Profile/AccessRights/${attribute}_${kind}`;
+            const i = relPath.lastIndexOf("/");
+            const full = node_opcua_data_model_1.AccessLevelFlag.CurrentRead | node_opcua_data_model_1.AccessLevelFlag.CurrentWrite | history;
+            const v = ctt.namespace.addVariable({
+                componentOf: ctt.folder(relPath.slice(0, i)),
+                browseName: relPath.slice(i + 1),
+                nodeId: ctt.nodeId(relPath),
+                description: `CTT setting ${relPath}`,
+                dataType: "Int32",
+                valueRank: -1,
+                accessLevel: full,
+                userAccessLevel: full,
+                value: new node_opcua_variant_1.Variant({ dataType: node_opcua_variant_1.DataType.Int32, value: 36 })
+            });
+            historize(ctt, v);
+            // installHistoricalDataNode() adds CurrentRead to both attributes: set the flags after it
+            v.accessLevel = attribute === "AccessLevel" ? flag : full;
+            v.userAccessLevel = attribute === "UserAccessLevel" ? flag : full;
+        }
+    }
+}
+// ─── entry point ────────────────────────────────────────────────────────
+function addCttFolder(namespace, objectsFolder) {
+    const root = namespace.addFolder(objectsFolder, {
+        browseName: "CTT",
+        nodeId: "s=CTT",
+        description: "Nodes named after the settings of the OPC Foundation Compliance Test Tool server project"
+    });
+    const ctt = new ctt_tree_js_1.CttFolder(namespace, root);
+    addVariantVariables(ctt);
+    addBooleanScalarAndArray(ctt);
+    addImageVariable(ctt);
+    addStructureVariables(ctt);
+    addAnalogItemArrays(ctt);
+    addArrayItems(ctt);
+    addHistorizingVariables(ctt);
+    (0, alarm_input_nodes_js_1.addAlarmInputNodes)(ctt);
+    return root;
+}
+//# sourceMappingURL=ctt_folder.js.map