@effect-opcua/client 0.1.0-alpha.1

package/dist/internal/batch/operations.mjs

@@ -0,0 +1,213 @@
+import { isPlainRecord } from "../common/predicates.mjs";
+import { configurationError } from "../../OpcuaError.mjs";
+import { readPreparedVariables, writePreparedVariables } from "../variable/operations.mjs";
+import { methodCallOptionsError } from "../method/arguments.mjs";
+import { callMethods, resolveMethod } from "../method/operations.mjs";
+import { normalizeServiceOptions, runKeyedBatchOperation, validateOptionsShape, validateUniqueTargets } from "./keyed.mjs";
+import { coerceNodeId } from "node-opcua";
+import { Effect } from "effect";
+
+//#region src/internal/batch/operations.ts
+const readManyWithState = (state, items, options) => runKeyedBatchOperation(items, options, state.batching?.readLimits, {
+	operation: "readMany",
+	normalizeOptions: normalizeReadManyOptions,
+	normalizeItem: normalizeReadManyItem,
+	validateItems: validateUniqueNodeIds("readMany.items"),
+	preflight: (entries, normalizedOptions) => Effect.gen(function* () {
+		if (normalizedOptions.validation === "strict") yield* Effect.forEach(entries, (entry) => state.metadata.variable(entry.normalized.def), { discard: true });
+		return entries;
+	}),
+	execute: (entries, normalizedOptions) => {
+		const prepared = entries.map((entry) => ({
+			def: entry.normalized.def,
+			rawNodeId: entry.normalized.rawNodeId
+		}));
+		return readPreparedVariables(state.unsafeRaw, prepared, state.structureRuntime, {
+			maxItemsPerRequest: normalizedOptions.maxNodesPerRequest,
+			maxConcurrentRequests: normalizedOptions.maxConcurrentRequests
+		});
+	},
+	toPublicResult: (_entry, raw) => Effect.succeed(raw)
+});
+const writeManyWithState = (state, items, options) => runKeyedBatchOperation(items, options, state.batching?.writeLimits, {
+	operation: "writeMany",
+	normalizeOptions: normalizeWriteManyOptions,
+	normalizeItem: normalizeWriteManyItem,
+	validateItems: validateUniqueNodeIds("writeMany.items"),
+	preflight: (entries) => Effect.forEach(entries, (entry) => Effect.map(state.metadata.variable(entry.normalized.def), (metadata) => ({
+		key: entry.key,
+		index: entry.index,
+		normalized: {
+			def: entry.normalized.def,
+			metadata,
+			value: entry.normalized.value,
+			rawNodeId: entry.normalized.rawNodeId
+		}
+	}))),
+	execute: (entries, normalizedOptions) => writePreparedVariables(state.unsafeRaw, entries.map((entry) => entry.normalized), state.structureRuntime, {
+		maxItemsPerRequest: normalizedOptions.maxNodesPerRequest,
+		maxConcurrentRequests: normalizedOptions.maxConcurrentRequests
+	}),
+	toPublicResult: (_entry, raw) => Effect.succeed(raw)
+});
+const callManyWithState = (state, items, options) => runKeyedBatchOperation(items, options, state.batching?.callLimits, {
+	operation: "callMany",
+	normalizeOptions: normalizeCallManyOptions,
+	normalizeItem: normalizeCallManyItem,
+	preflight: (entries) => Effect.forEach(entries, (entry) => Effect.gen(function* () {
+		const methodMetadata = yield* state.metadata.method(entry.normalized.def);
+		const method = yield* resolveMethod(entry.normalized.def, methodMetadata);
+		return {
+			key: entry.key,
+			index: entry.index,
+			normalized: {
+				method,
+				input: entry.normalized.input,
+				options: entry.normalized.options
+			}
+		};
+	})),
+	execute: (entries, normalizedOptions) => callMethods(state.unsafeRaw, entries.map((entry) => entry.normalized), state.structureRuntime, {
+		maxItemsPerRequest: normalizedOptions.maxNodesPerRequest,
+		maxConcurrentRequests: normalizedOptions.maxConcurrentRequests
+	}),
+	toPublicResult: (_entry, raw) => Effect.succeed(raw)
+});
+const normalizeReadManyItem = (key, value) => Effect.suspend(() => {
+	if (!isReadableVariableDef(value)) return Effect.fail(configurationError({
+		operation: "readMany.items",
+		key,
+		cause: "items must be readable variable definitions"
+	}));
+	const rawNodeId = coerceNodeIdForKey("readMany.items", key, value.nodeId);
+	if (rawNodeId instanceof Error) return Effect.fail(rawNodeId);
+	return Effect.succeed({
+		def: value,
+		nodeId: rawNodeId.toString(),
+		rawNodeId
+	});
+});
+const normalizeWriteManyItem = (key, tuple) => Effect.suspend(() => {
+	if (!Array.isArray(tuple) || tuple.length !== 2) return Effect.fail(configurationError({
+		operation: "writeMany.items",
+		key,
+		cause: "write entries must be [definition, value] tuples"
+	}));
+	const [def, value] = tuple;
+	if (!isWritableVariableDef(def)) return Effect.fail(configurationError({
+		operation: "writeMany.items",
+		key,
+		cause: "write entries must use writable variable definitions"
+	}));
+	const rawNodeId = coerceNodeIdForKey("writeMany.items", key, def.nodeId);
+	if (rawNodeId instanceof Error) return Effect.fail(rawNodeId);
+	return Effect.succeed({
+		def,
+		value,
+		nodeId: rawNodeId.toString(),
+		rawNodeId
+	});
+});
+const normalizeCallManyItem = (key, tuple) => Effect.suspend(() => {
+	if (!Array.isArray(tuple) || tuple.length !== 2 && tuple.length !== 3) return Effect.fail(configurationError({
+		operation: "callMany.items",
+		key,
+		cause: "call entries must be [definition, input] or [definition, input, options] tuples"
+	}));
+	const [def, input, itemOptions] = tuple;
+	if (!isMethodDef(def)) return Effect.fail(configurationError({
+		operation: "callMany.items",
+		key,
+		cause: "call entries must use method definitions"
+	}));
+	const optionsError = methodCallOptionsError("callMany.items.options", def.objectId, def.methodId, itemOptions);
+	if (optionsError) return Effect.fail(optionsError);
+	return Effect.succeed({
+		def,
+		input,
+		options: itemOptions
+	});
+});
+const validateUniqueNodeIds = (operation) => (entries) => validateUniqueTargets(entries, {
+	operation,
+	target: (entry) => entry.normalized.nodeId,
+	duplicateCause: (_target, previousKey) => `duplicate NodeId also used by ${previousKey}`,
+	errorContext: (_entry, nodeId) => ({ nodeId })
+});
+const validateBatchOptionsShape = (operation, options, keys = []) => validateOptionsShape(operation, options, [
+	...keys,
+	"service",
+	"serviceLimitsOverrides"
+]);
+const serviceOptions = (options) => options?.service ?? options?.serviceLimitsOverrides;
+const normalizeReadManyOptions = (options, defaults) => Effect.gen(function* () {
+	yield* validateBatchOptionsShape("readMany.options", options, ["validation"]);
+	if (options?.validation !== void 0 && options.validation !== "strict" && options.validation !== "none") return yield* Effect.fail(configurationError({
+		operation: "readMany.options.validation",
+		cause: "validation must be \"strict\" or \"none\""
+	}));
+	const service = yield* normalizeServiceOptions({
+		serviceLimits: serviceOptions(options),
+		defaults,
+		serviceOperation: "readMany.options.service",
+		defaultsOperation: "OpcuaSession.batching.read",
+		allowedKeys: ["maxNodesPerRequest", "maxConcurrentRequests"],
+		fallback: {
+			maxNodesPerRequest: 250,
+			maxConcurrentRequests: 1
+		}
+	});
+	return {
+		validation: options?.validation ?? "strict",
+		...service
+	};
+});
+const normalizeWriteManyOptions = (options, defaults) => Effect.gen(function* () {
+	yield* validateBatchOptionsShape("writeMany.options", options);
+	return yield* normalizeServiceOptions({
+		serviceLimits: serviceOptions(options),
+		defaults,
+		serviceOperation: "writeMany.options.service",
+		defaultsOperation: "OpcuaSession.batching.write",
+		allowedKeys: ["maxNodesPerRequest", "maxConcurrentRequests"],
+		fallback: {
+			maxNodesPerRequest: 250,
+			maxConcurrentRequests: 1
+		}
+	});
+});
+const normalizeCallManyOptions = (options, defaults) => Effect.gen(function* () {
+	yield* validateBatchOptionsShape("callMany.options", options);
+	return yield* normalizeServiceOptions({
+		serviceLimits: serviceOptions(options),
+		defaults,
+		serviceOperation: "callMany.options.service",
+		defaultsOperation: "OpcuaSession.batching.call",
+		allowedKeys: ["maxNodesPerRequest", "maxConcurrentRequests"],
+		fallback: {
+			maxNodesPerRequest: 50,
+			maxConcurrentRequests: 1
+		}
+	});
+});
+const coerceNodeIdForKey = (operation, key, nodeId) => {
+	try {
+		return coerceNodeId(nodeId);
+	} catch (cause) {
+		return configurationError({
+			operation,
+			key,
+			nodeId,
+			cause
+		});
+	}
+};
+const isReadableVariableDef = (value) => isVariableDef(value) && (value.access === "read" || value.access === "readWrite");
+const isWritableVariableDef = (value) => isVariableDef(value) && (value.access === "write" || value.access === "readWrite");
+const isVariableDef = (value) => isPlainRecord(value) && value._tag === "VariableDef" && typeof value.nodeId === "string" && isVariableAccess(value.access) && isPlainRecord(value.codec);
+const isMethodDef = (value) => isPlainRecord(value) && value._tag === "MethodDef" && typeof value.objectId === "string" && typeof value.methodId === "string";
+const isVariableAccess = (value) => value === "read" || value === "write" || value === "readWrite";
+
+//#endregion
+export { callManyWithState, readManyWithState, writeManyWithState };
+//# sourceMappingURL=operations.mjs.map

package/dist/internal/batch/operations.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations.mjs","names":["prepared: ReadonlyArray<VariableOperations.PreparedReadVariable>","VariableOperations.readPreparedVariables","VariableOperations.writePreparedVariables","MethodOperations.resolveMethod","MethodOperations.callMethods","OpcuaError.configurationError","MethodArguments.methodCallOptionsError"],"sources":["../../../src/internal/batch/operations.ts"],"sourcesContent":["import { coerceNodeId, type ClientSession, type NodeId } from \"node-opcua\";\nimport { Effect } from \"effect\";\n\nimport * as OpcuaError from \"../../OpcuaError.js\";\nimport * as OpcuaMethod from \"../../OpcuaMethod.js\";\nimport * as OpcuaVariable from \"../../OpcuaVariable.js\";\nimport * as MethodArguments from \"../method/arguments.js\";\nimport * as MethodOperations from \"../method/operations.js\";\nimport * as VariableOperations from \"../variable/operations.js\";\nimport {\n  normalizeServiceOptions,\n  runKeyedBatchOperation,\n  validateOptionsShape,\n  validateUniqueTargets,\n  type KeyedEntry,\n} from \"./keyed.js\";\nimport { isPlainRecord } from \"../common/predicates.js\";\nimport type { makeMetadataService } from \"../metadata/service.js\";\nimport type { makeStructureRuntime } from \"../structures/runtime.js\";\nimport type { NodeIdString } from \"../common/node-id.js\";\nimport type {\n  CallManyOptions,\n  ReadManyOptions,\n  ServiceOptions,\n  ServiceLimits,\n  SessionBatchingOptions,\n  WriteManyOptions,\n} from \"../../OpcuaSession.js\";\nimport type { MethodCallOptions } from \"../../OpcuaMethod.js\";\nexport type {\n  CallManyOptions,\n  ReadManyOptions,\n  ServiceOptions,\n  ServiceLimits,\n  SessionBatchingOptions,\n  WriteManyOptions,\n} from \"../../OpcuaSession.js\";\nexport type { MethodCallOptions } from \"../../OpcuaMethod.js\";\n\nexport type SessionOperationsState = {\n  readonly unsafeRaw: ClientSession;\n  readonly metadata: ReturnType<typeof makeMetadataService>;\n  readonly structureRuntime: ReturnType<typeof makeStructureRuntime>;\n  readonly batching?: SessionBatchingOptions;\n};\n\ntype AnyWriteManyRecord = Record<\n  string,\n  readonly [OpcuaVariable.WritableVariableDef, unknown]\n>;\n\ntype AnyCallManyRecord = Record<\n  string,\n  | readonly [OpcuaMethod.AnyMethodDef, unknown]\n  | readonly [OpcuaMethod.AnyMethodDef, unknown, MethodCallOptions]\n>;\n\ntype NormalizedReadItem = {\n  readonly def: OpcuaVariable.ReadableVariableDef;\n  readonly nodeId: NodeIdString;\n  readonly rawNodeId: NodeId;\n};\n\ntype NormalizedWriteItem = {\n  readonly def: OpcuaVariable.WritableVariableDef;\n  readonly value: unknown;\n  readonly nodeId: NodeIdString;\n  readonly rawNodeId: NodeId;\n};\n\ntype NormalizedCallItem = {\n  readonly def: OpcuaMethod.AnyMethodDef;\n  readonly input: unknown;\n  readonly options?: MethodCallOptions;\n};\n\nexport const readManyWithState = <\n  const Items extends Record<string, OpcuaVariable.ReadableVariableDef>,\n>(\n  state: SessionOperationsState,\n  items: Items,\n  options?: ReadManyOptions,\n): Effect.Effect<OpcuaVariable.ReadManyResult<Items>, OpcuaError.OpcuaError> =>\n  runKeyedBatchOperation(items, options, state.batching?.readLimits, {\n    operation: \"readMany\",\n    normalizeOptions: normalizeReadManyOptions,\n    normalizeItem: normalizeReadManyItem,\n    validateItems: validateUniqueNodeIds(\"readMany.items\"),\n    preflight: (entries, normalizedOptions) =>\n      Effect.gen(function* () {\n        if (normalizedOptions.validation === \"strict\") {\n          yield* Effect.forEach(\n            entries,\n            (entry) => state.metadata.variable(entry.normalized.def),\n            { discard: true },\n          );\n        }\n        return entries;\n      }),\n    execute: (entries, normalizedOptions) => {\n      const prepared: ReadonlyArray<VariableOperations.PreparedReadVariable> =\n        entries.map((entry) => ({\n          def: entry.normalized.def,\n          rawNodeId: entry.normalized.rawNodeId,\n        }));\n      return VariableOperations.readPreparedVariables(\n        state.unsafeRaw,\n        prepared,\n        state.structureRuntime,\n        {\n          maxItemsPerRequest: normalizedOptions.maxNodesPerRequest,\n          maxConcurrentRequests: normalizedOptions.maxConcurrentRequests,\n        },\n      );\n    },\n    toPublicResult: (_entry, raw) => Effect.succeed(raw),\n  }) as Effect.Effect<\n    OpcuaVariable.ReadManyResult<Items>,\n    OpcuaError.OpcuaError\n  >;\n\nexport const writeManyWithState = <const Items extends AnyWriteManyRecord>(\n  state: SessionOperationsState,\n  items: Items & OpcuaVariable.WriteManyInput<Items>,\n  options?: WriteManyOptions,\n): Effect.Effect<OpcuaVariable.WriteManyResult<Items>, OpcuaError.OpcuaError> =>\n  runKeyedBatchOperation(items, options, state.batching?.writeLimits, {\n    operation: \"writeMany\",\n    normalizeOptions: normalizeWriteManyOptions,\n    normalizeItem: normalizeWriteManyItem,\n    validateItems: validateUniqueNodeIds(\"writeMany.items\"),\n    preflight: (entries) =>\n      Effect.forEach(entries, (entry) =>\n        Effect.map(\n          state.metadata.variable(entry.normalized.def),\n          (\n            metadata,\n          ): KeyedEntry<string, VariableOperations.PreparedWriteVariable> => ({\n            key: entry.key,\n            index: entry.index,\n            normalized: {\n              def: entry.normalized.def,\n              metadata,\n              value: entry.normalized.value,\n              rawNodeId: entry.normalized.rawNodeId,\n            },\n          }),\n        ),\n      ),\n    execute: (entries, normalizedOptions) =>\n      VariableOperations.writePreparedVariables(\n        state.unsafeRaw,\n        entries.map((entry) => entry.normalized),\n        state.structureRuntime,\n        {\n          maxItemsPerRequest: normalizedOptions.maxNodesPerRequest,\n          maxConcurrentRequests: normalizedOptions.maxConcurrentRequests,\n        },\n      ),\n    toPublicResult: (_entry, raw) => Effect.succeed(raw),\n  }) as Effect.Effect<\n    OpcuaVariable.WriteManyResult<Items>,\n    OpcuaError.OpcuaError\n  >;\n\nexport const callManyWithState = <const Items extends AnyCallManyRecord>(\n  state: SessionOperationsState,\n  items: Items & OpcuaMethod.CallManyInput<Items>,\n  options?: CallManyOptions,\n): Effect.Effect<OpcuaMethod.CallManyResult<Items>, OpcuaError.OpcuaError> =>\n  runKeyedBatchOperation(items, options, state.batching?.callLimits, {\n    operation: \"callMany\",\n    normalizeOptions: normalizeCallManyOptions,\n    normalizeItem: normalizeCallManyItem,\n    preflight: (entries) =>\n      Effect.forEach(entries, (entry) =>\n        Effect.gen(function* () {\n          const methodMetadata = yield* state.metadata.method(\n            entry.normalized.def,\n          );\n          const method = yield* MethodOperations.resolveMethod(\n            entry.normalized.def,\n            methodMetadata,\n          );\n          return {\n            key: entry.key,\n            index: entry.index,\n            normalized: {\n              method,\n              input: entry.normalized.input,\n              options: entry.normalized.options,\n            } as OpcuaMethod.MethodCallEntry<OpcuaMethod.AnyResolvedMethod>,\n          };\n        }),\n      ),\n    execute: (entries, normalizedOptions) =>\n      MethodOperations.callMethods(\n        state.unsafeRaw,\n        entries.map((entry) => entry.normalized),\n        state.structureRuntime,\n        {\n          maxItemsPerRequest: normalizedOptions.maxNodesPerRequest,\n          maxConcurrentRequests: normalizedOptions.maxConcurrentRequests,\n        },\n      ),\n    toPublicResult: (_entry, raw) => Effect.succeed(raw),\n  }) as Effect.Effect<OpcuaMethod.CallManyResult<Items>, OpcuaError.OpcuaError>;\n\nconst normalizeReadManyItem = (\n  key: string,\n  value: OpcuaVariable.ReadableVariableDef,\n): Effect.Effect<NormalizedReadItem, OpcuaError.OpcuaError> =>\n  Effect.suspend(() => {\n    if (!isReadableVariableDef(value)) {\n      return Effect.fail(\n        OpcuaError.configurationError({\n          operation: \"readMany.items\",\n          key,\n          cause: \"items must be readable variable definitions\",\n        }),\n      );\n    }\n    const rawNodeId = coerceNodeIdForKey(\"readMany.items\", key, value.nodeId);\n    if (rawNodeId instanceof Error)\n      return Effect.fail(rawNodeId as OpcuaError.OpcuaError);\n    return Effect.succeed({\n      def: value,\n      nodeId: rawNodeId.toString(),\n      rawNodeId,\n    });\n  });\n\nconst normalizeWriteManyItem = (\n  key: string,\n  tuple: readonly [OpcuaVariable.WritableVariableDef, unknown],\n): Effect.Effect<NormalizedWriteItem, OpcuaError.OpcuaError> =>\n  Effect.suspend(() => {\n    if (!Array.isArray(tuple) || tuple.length !== 2) {\n      return Effect.fail(\n        OpcuaError.configurationError({\n          operation: \"writeMany.items\",\n          key,\n          cause: \"write entries must be [definition, value] tuples\",\n        }),\n      );\n    }\n    const [def, value] = tuple;\n    if (!isWritableVariableDef(def)) {\n      return Effect.fail(\n        OpcuaError.configurationError({\n          operation: \"writeMany.items\",\n          key,\n          cause: \"write entries must use writable variable definitions\",\n        }),\n      );\n    }\n    const rawNodeId = coerceNodeIdForKey(\"writeMany.items\", key, def.nodeId);\n    if (rawNodeId instanceof Error)\n      return Effect.fail(rawNodeId as OpcuaError.OpcuaError);\n    return Effect.succeed({\n      def,\n      value,\n      nodeId: rawNodeId.toString(),\n      rawNodeId,\n    });\n  });\n\nconst normalizeCallManyItem = (\n  key: string,\n  tuple:\n    | readonly [OpcuaMethod.AnyMethodDef, unknown]\n    | readonly [OpcuaMethod.AnyMethodDef, unknown, MethodCallOptions],\n): Effect.Effect<NormalizedCallItem, OpcuaError.OpcuaError> =>\n  Effect.suspend(() => {\n    if (!Array.isArray(tuple) || (tuple.length !== 2 && tuple.length !== 3)) {\n      return Effect.fail(\n        OpcuaError.configurationError({\n          operation: \"callMany.items\",\n          key,\n          cause:\n            \"call entries must be [definition, input] or [definition, input, options] tuples\",\n        }),\n      );\n    }\n    const [def, input, itemOptions] = tuple;\n    if (!isMethodDef(def)) {\n      return Effect.fail(\n        OpcuaError.configurationError({\n          operation: \"callMany.items\",\n          key,\n          cause: \"call entries must use method definitions\",\n        }),\n      );\n    }\n    const optionsError = MethodArguments.methodCallOptionsError(\n      \"callMany.items.options\",\n      def.objectId,\n      def.methodId,\n      itemOptions as MethodCallOptions | undefined,\n    );\n    if (optionsError) return Effect.fail(optionsError);\n    return Effect.succeed({\n      def,\n      input,\n      options: itemOptions as MethodCallOptions | undefined,\n    });\n  });\n\nconst validateUniqueNodeIds =\n  (operation: string) =>\n  (\n    entries: ReadonlyArray<\n      KeyedEntry<string, { readonly nodeId: NodeIdString }>\n    >,\n  ) =>\n    validateUniqueTargets(entries, {\n      operation,\n      target: (entry) => entry.normalized.nodeId,\n      duplicateCause: (_target, previousKey) =>\n        `duplicate NodeId also used by ${previousKey}`,\n      errorContext: (_entry, nodeId) => ({ nodeId }),\n    });\n\nconst validateBatchOptionsShape = (\n  operation: string,\n  options: ServiceOptions | undefined,\n  keys: ReadonlyArray<string> = [],\n) =>\n  validateOptionsShape(operation, options, [\n    ...keys,\n    \"service\",\n    \"serviceLimitsOverrides\",\n  ]);\n\nconst serviceOptions = (options: ServiceOptions | undefined) =>\n  options?.service ?? options?.serviceLimitsOverrides;\n\nconst normalizeReadManyOptions = (\n  options: ReadManyOptions | undefined,\n  defaults: SessionBatchingOptions[\"readLimits\"] | undefined,\n): Effect.Effect<\n  ServiceLimits & { readonly validation: \"strict\" | \"none\" },\n  OpcuaError.OpcuaError\n> =>\n  Effect.gen(function* () {\n    yield* validateBatchOptionsShape(\"readMany.options\", options, [\n      \"validation\",\n    ]);\n    if (\n      options?.validation !== undefined &&\n      options.validation !== \"strict\" &&\n      options.validation !== \"none\"\n    ) {\n      return yield* Effect.fail(\n        OpcuaError.configurationError({\n          operation: \"readMany.options.validation\",\n          cause: 'validation must be \"strict\" or \"none\"',\n        }),\n      );\n    }\n\n    const service = yield* normalizeServiceOptions<\n      \"maxNodesPerRequest\" | \"maxConcurrentRequests\"\n    >({\n      serviceLimits: serviceOptions(options),\n      defaults,\n      serviceOperation: \"readMany.options.service\",\n      defaultsOperation: \"OpcuaSession.batching.read\",\n      allowedKeys: [\"maxNodesPerRequest\", \"maxConcurrentRequests\"],\n      fallback: {\n        maxNodesPerRequest: 250,\n        maxConcurrentRequests: 1,\n      },\n    });\n    return {\n      validation: options?.validation ?? \"strict\",\n      ...service,\n    };\n  });\n\nconst normalizeWriteManyOptions = (\n  options: WriteManyOptions | undefined,\n  defaults: SessionBatchingOptions[\"writeLimits\"] | undefined,\n): Effect.Effect<ServiceLimits, OpcuaError.OpcuaError> =>\n  Effect.gen(function* () {\n    yield* validateBatchOptionsShape(\"writeMany.options\", options);\n    return yield* normalizeServiceOptions<\n      \"maxNodesPerRequest\" | \"maxConcurrentRequests\"\n    >({\n      serviceLimits: serviceOptions(options),\n      defaults,\n      serviceOperation: \"writeMany.options.service\",\n      defaultsOperation: \"OpcuaSession.batching.write\",\n      allowedKeys: [\"maxNodesPerRequest\", \"maxConcurrentRequests\"],\n      fallback: {\n        maxNodesPerRequest: 250,\n        maxConcurrentRequests: 1,\n      },\n    });\n  });\n\nconst normalizeCallManyOptions = (\n  options: CallManyOptions | undefined,\n  defaults: SessionBatchingOptions[\"callLimits\"] | undefined,\n): Effect.Effect<ServiceLimits, OpcuaError.OpcuaError> =>\n  Effect.gen(function* () {\n    yield* validateBatchOptionsShape(\"callMany.options\", options);\n    return yield* normalizeServiceOptions<\n      \"maxNodesPerRequest\" | \"maxConcurrentRequests\"\n    >({\n      serviceLimits: serviceOptions(options),\n      defaults,\n      serviceOperation: \"callMany.options.service\",\n      defaultsOperation: \"OpcuaSession.batching.call\",\n      allowedKeys: [\"maxNodesPerRequest\", \"maxConcurrentRequests\"],\n      fallback: {\n        maxNodesPerRequest: 50,\n        maxConcurrentRequests: 1,\n      },\n    });\n  });\n\nconst coerceNodeIdForKey = (\n  operation: string,\n  key: string,\n  nodeId: NodeIdString,\n) => {\n  try {\n    return coerceNodeId(nodeId);\n  } catch (cause) {\n    return OpcuaError.configurationError({ operation, key, nodeId, cause });\n  }\n};\n\nconst isReadableVariableDef = (\n  value: unknown,\n): value is OpcuaVariable.ReadableVariableDef =>\n  isVariableDef(value) &&\n  (value.access === \"read\" || value.access === \"readWrite\");\n\nconst isWritableVariableDef = (\n  value: unknown,\n): value is OpcuaVariable.WritableVariableDef =>\n  isVariableDef(value) &&\n  (value.access === \"write\" || value.access === \"readWrite\");\n\nconst isVariableDef = (value: unknown): value is OpcuaVariable.AnyVariableDef =>\n  isPlainRecord(value) &&\n  value._tag === \"VariableDef\" &&\n  typeof value.nodeId === \"string\" &&\n  isVariableAccess(value.access) &&\n  isPlainRecord(value.codec);\n\nconst isMethodDef = (value: unknown): value is OpcuaMethod.AnyMethodDef =>\n  isPlainRecord(value) &&\n  value._tag === \"MethodDef\" &&\n  typeof value.objectId === \"string\" &&\n  typeof value.methodId === \"string\";\n\nconst isVariableAccess = (\n  value: unknown,\n): value is OpcuaVariable.VariableAccess =>\n  value === \"read\" || value === \"write\" || value === \"readWrite\";\n"],"mappings":"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"}

package/dist/internal/browse/operations.d.mts

@@ -0,0 +1,15 @@
+import { NodeIdString } from "../../OpcuaVariable.mjs";
+import "../common/node-id.mjs";
+import { OpcuaConfigurationError } from "../../OpcuaError.mjs";
+import { OpcuaBrowseChildrenOptions, OpcuaBrowseChildrenResult, OpcuaBrowseContinuation, OpcuaBrowseOptions, OpcuaBrowseReference, OpcuaBrowseResult } from "../../OpcuaSession.mjs";
+import { BrowseDescriptionOptions, BrowseResult, ClientSession, ReferenceDescription } from "node-opcua";
+
+//#region src/internal/browse/operations.d.ts
+declare const browseOptionsError: (input: OpcuaBrowseOptions) => OpcuaConfigurationError | undefined;
+declare const browseContinuationError: (operation: string, continuation: OpcuaBrowseContinuation) => OpcuaConfigurationError | undefined;
+declare const browseWithMaxReferences: (session: ClientSession, nodeToBrowse: BrowseDescriptionOptions, maxReferencesPerNode: number) => Promise<BrowseResult>;
+declare const normalizeBrowseResult: (nodeId: NodeIdString, result: BrowseResult, includeRaw: boolean) => OpcuaBrowseResult;
+declare const normalizeBrowseReference: (reference: ReferenceDescription, includeRaw: boolean) => OpcuaBrowseReference;
+//#endregion
+export { type OpcuaBrowseChildrenOptions, type OpcuaBrowseChildrenResult, type OpcuaBrowseContinuation, type OpcuaBrowseOptions, type OpcuaBrowseReference, type OpcuaBrowseResult, browseContinuationError, browseOptionsError, browseWithMaxReferences, normalizeBrowseReference, normalizeBrowseResult };
+//# sourceMappingURL=operations.d.mts.map

package/dist/internal/browse/operations.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations.d.mts","names":[],"sources":["../../../src/internal/browse/operations.ts"],"sourcesContent":[],"mappings":";;;;;;;cAiCa,4BAA6B,uBAAkB,uBAAA;cAqB/C,2DAEG,4BAAuB,uBAAA;cAmB1B,mCACF,6BACK,2DAEb,QAAQ;AA9CE,cAwDA,qBAxD6B,EAAA,CAAA,MAAA,EAyDhC,YAzDkD,EAAA,MAAA,EA0DlD,YA1DkD,EAAA,UAAA,EAAA,OAAA,EAAA,GA4DzD,iBA5DyD;AAqB/C,cAiEA,wBA/DG,EAAA,CAAA,SAAA,EAgEH,oBAhE0B,EAAA,UAAA,EAAA,OAAA,EAAA,GAkEpC,oBAlEoC"}

package/dist/internal/browse/operations.mjs

@@ -0,0 +1,72 @@
+import { isGood, normalizeExpandedNodeId, normalizeLocalizedText, normalizeQualifiedName, normalizeStatusCode } from "../values/normalize.mjs";
+import { configurationError } from "../../OpcuaError.mjs";
+import { nonNegativeIntegerOption } from "../common/options.mjs";
+import { NodeClass } from "node-opcua";
+
+//#region src/internal/browse/operations.ts
+const browseOptionsError = (input) => {
+	if (input.nodeId.trim() === "") return configurationError({
+		operation: "browse",
+		nodeId: input.nodeId,
+		cause: "nodeId must not be empty"
+	});
+	if (input.maxReferencesPerNode !== void 0 && !nonNegativeIntegerOption(input.maxReferencesPerNode)) return configurationError({
+		operation: "browse",
+		nodeId: input.nodeId,
+		cause: "maxReferencesPerNode must be a non-negative integer"
+	});
+};
+const browseContinuationError = (operation, continuation) => {
+	if (continuation.nodeId.trim() === "") return configurationError({
+		operation,
+		nodeId: continuation.nodeId,
+		cause: "nodeId must not be empty"
+	});
+	if (continuation.unsafeRaw.length === 0) return configurationError({
+		operation,
+		nodeId: continuation.nodeId,
+		cause: "continuation raw buffer must not be empty"
+	});
+};
+const browseWithMaxReferences = async (session, nodeToBrowse, maxReferencesPerNode) => {
+	const previousMaxReferencesPerNode = session.requestedMaxReferencesPerNode;
+	session.requestedMaxReferencesPerNode = maxReferencesPerNode;
+	try {
+		return await session.browse(nodeToBrowse);
+	} finally {
+		session.requestedMaxReferencesPerNode = previousMaxReferencesPerNode;
+	}
+};
+const normalizeBrowseResult = (nodeId, result, includeRaw) => {
+	if (!isGood(result.statusCode)) return {
+		_tag: "NonGoodStatus",
+		nodeId,
+		status: normalizeStatusCode(result.statusCode),
+		unsafeRaw: includeRaw ? result : void 0
+	};
+	return {
+		_tag: "Browsed",
+		nodeId,
+		status: normalizeStatusCode(result.statusCode),
+		references: result.references?.map((reference) => normalizeBrowseReference(reference, includeRaw)) ?? [],
+		continuation: result.continuationPoint && result.continuationPoint.length > 0 ? {
+			nodeId,
+			unsafeRaw: result.continuationPoint
+		} : void 0,
+		unsafeRaw: includeRaw ? result : void 0
+	};
+};
+const normalizeBrowseReference = (reference, includeRaw) => ({
+	nodeId: normalizeExpandedNodeId(reference.nodeId),
+	referenceTypeId: reference.referenceTypeId?.toString(),
+	isForward: reference.isForward,
+	nodeClass: typeof reference.nodeClass === "number" ? NodeClass[reference.nodeClass] : void 0,
+	browseName: reference.browseName ? normalizeQualifiedName(reference.browseName) : void 0,
+	displayName: reference.displayName ? normalizeLocalizedText(reference.displayName) : void 0,
+	typeDefinition: reference.typeDefinition ? normalizeExpandedNodeId(reference.typeDefinition) : void 0,
+	unsafeRaw: includeRaw ? reference : void 0
+});
+
+//#endregion
+export { browseContinuationError, browseOptionsError, browseWithMaxReferences, normalizeBrowseReference, normalizeBrowseResult };
+//# sourceMappingURL=operations.mjs.map

package/dist/internal/browse/operations.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations.mjs","names":[],"sources":["../../../src/internal/browse/operations.ts"],"sourcesContent":["import {\n  NodeClass,\n  type BrowseDescriptionOptions,\n  type BrowseResult,\n  type ClientSession,\n  type ReferenceDescription,\n} from \"node-opcua\";\n\nimport { configurationError } from \"../../OpcuaError.js\";\nimport type {\n  OpcuaBrowseContinuation,\n  OpcuaBrowseOptions,\n  OpcuaBrowseReference,\n  OpcuaBrowseResult,\n} from \"../../OpcuaSession.js\";\nimport {\n  isGood,\n  normalizeExpandedNodeId,\n  normalizeLocalizedText,\n  normalizeQualifiedName,\n  normalizeStatusCode,\n} from \"../values/normalize.js\";\nimport type { NodeIdString } from \"../common/node-id.js\";\nimport { nonNegativeIntegerOption } from \"../common/options.js\";\nexport type {\n  OpcuaBrowseChildrenOptions,\n  OpcuaBrowseChildrenResult,\n  OpcuaBrowseContinuation,\n  OpcuaBrowseOptions,\n  OpcuaBrowseReference,\n  OpcuaBrowseResult,\n} from \"../../OpcuaSession.js\";\n\nexport const browseOptionsError = (input: OpcuaBrowseOptions) => {\n  if (input.nodeId.trim() === \"\") {\n    return configurationError({\n      operation: \"browse\",\n      nodeId: input.nodeId,\n      cause: \"nodeId must not be empty\",\n    });\n  }\n  if (\n    input.maxReferencesPerNode !== undefined &&\n    !nonNegativeIntegerOption(input.maxReferencesPerNode)\n  ) {\n    return configurationError({\n      operation: \"browse\",\n      nodeId: input.nodeId,\n      cause: \"maxReferencesPerNode must be a non-negative integer\",\n    });\n  }\n  return undefined;\n};\n\nexport const browseContinuationError = (\n  operation: string,\n  continuation: OpcuaBrowseContinuation,\n) => {\n  if (continuation.nodeId.trim() === \"\") {\n    return configurationError({\n      operation,\n      nodeId: continuation.nodeId,\n      cause: \"nodeId must not be empty\",\n    });\n  }\n  if (continuation.unsafeRaw.length === 0) {\n    return configurationError({\n      operation,\n      nodeId: continuation.nodeId,\n      cause: \"continuation raw buffer must not be empty\",\n    });\n  }\n  return undefined;\n};\n\nexport const browseWithMaxReferences = async (\n  session: ClientSession,\n  nodeToBrowse: BrowseDescriptionOptions,\n  maxReferencesPerNode: number,\n): Promise<BrowseResult> => {\n  const previousMaxReferencesPerNode = session.requestedMaxReferencesPerNode;\n  session.requestedMaxReferencesPerNode = maxReferencesPerNode;\n  try {\n    return await session.browse(nodeToBrowse);\n  } finally {\n    session.requestedMaxReferencesPerNode = previousMaxReferencesPerNode;\n  }\n};\n\nexport const normalizeBrowseResult = (\n  nodeId: NodeIdString,\n  result: BrowseResult,\n  includeRaw: boolean,\n): OpcuaBrowseResult => {\n  if (!isGood(result.statusCode)) {\n    return {\n      _tag: \"NonGoodStatus\",\n      nodeId,\n      status: normalizeStatusCode(result.statusCode),\n      unsafeRaw: includeRaw ? result : undefined,\n    };\n  }\n\n  return {\n    _tag: \"Browsed\",\n    nodeId,\n    status: normalizeStatusCode(result.statusCode),\n    references:\n      result.references?.map((reference) =>\n        normalizeBrowseReference(reference, includeRaw),\n      ) ?? [],\n    continuation:\n      result.continuationPoint && result.continuationPoint.length > 0\n        ? { nodeId, unsafeRaw: result.continuationPoint }\n        : undefined,\n    unsafeRaw: includeRaw ? result : undefined,\n  };\n};\n\nexport const normalizeBrowseReference = (\n  reference: ReferenceDescription,\n  includeRaw: boolean,\n): OpcuaBrowseReference => ({\n  nodeId: normalizeExpandedNodeId(reference.nodeId),\n  referenceTypeId: reference.referenceTypeId?.toString(),\n  isForward: reference.isForward,\n  nodeClass:\n    typeof reference.nodeClass === \"number\"\n      ? NodeClass[reference.nodeClass]\n      : undefined,\n  browseName: reference.browseName\n    ? normalizeQualifiedName(reference.browseName)\n    : undefined,\n  displayName: reference.displayName\n    ? normalizeLocalizedText(reference.displayName)\n    : undefined,\n  typeDefinition: reference.typeDefinition\n    ? normalizeExpandedNodeId(reference.typeDefinition)\n    : undefined,\n  unsafeRaw: includeRaw ? reference : undefined,\n});\n"],"mappings":";;;;;;AAiCA,MAAa,sBAAsB,UAA8B;AAC/D,KAAI,MAAM,OAAO,MAAM,KAAK,GAC1B,QAAO,mBAAmB;EACxB,WAAW;EACX,QAAQ,MAAM;EACd,OAAO;EACR,CAAC;AAEJ,KACE,MAAM,yBAAyB,UAC/B,CAAC,yBAAyB,MAAM,qBAAqB,CAErD,QAAO,mBAAmB;EACxB,WAAW;EACX,QAAQ,MAAM;EACd,OAAO;EACR,CAAC;;AAKN,MAAa,2BACX,WACA,iBACG;AACH,KAAI,aAAa,OAAO,MAAM,KAAK,GACjC,QAAO,mBAAmB;EACxB;EACA,QAAQ,aAAa;EACrB,OAAO;EACR,CAAC;AAEJ,KAAI,aAAa,UAAU,WAAW,EACpC,QAAO,mBAAmB;EACxB;EACA,QAAQ,aAAa;EACrB,OAAO;EACR,CAAC;;AAKN,MAAa,0BAA0B,OACrC,SACA,cACA,yBAC0B;CAC1B,MAAM,+BAA+B,QAAQ;AAC7C,SAAQ,gCAAgC;AACxC,KAAI;AACF,SAAO,MAAM,QAAQ,OAAO,aAAa;WACjC;AACR,UAAQ,gCAAgC;;;AAI5C,MAAa,yBACX,QACA,QACA,eACsB;AACtB,KAAI,CAAC,OAAO,OAAO,WAAW,CAC5B,QAAO;EACL,MAAM;EACN;EACA,QAAQ,oBAAoB,OAAO,WAAW;EAC9C,WAAW,aAAa,SAAS;EAClC;AAGH,QAAO;EACL,MAAM;EACN;EACA,QAAQ,oBAAoB,OAAO,WAAW;EAC9C,YACE,OAAO,YAAY,KAAK,cACtB,yBAAyB,WAAW,WAAW,CAChD,IAAI,EAAE;EACT,cACE,OAAO,qBAAqB,OAAO,kBAAkB,SAAS,IAC1D;GAAE;GAAQ,WAAW,OAAO;GAAmB,GAC/C;EACN,WAAW,aAAa,SAAS;EAClC;;AAGH,MAAa,4BACX,WACA,gBAC0B;CAC1B,QAAQ,wBAAwB,UAAU,OAAO;CACjD,iBAAiB,UAAU,iBAAiB,UAAU;CACtD,WAAW,UAAU;CACrB,WACE,OAAO,UAAU,cAAc,WAC3B,UAAU,UAAU,aACpB;CACN,YAAY,UAAU,aAClB,uBAAuB,UAAU,WAAW,GAC5C;CACJ,aAAa,UAAU,cACnB,uBAAuB,UAAU,YAAY,GAC7C;CACJ,gBAAgB,UAAU,iBACtB,wBAAwB,UAAU,eAAe,GACjD;CACJ,WAAW,aAAa,YAAY;CACrC"}

package/dist/internal/client/make.d.mts

@@ -0,0 +1,16 @@
+import { OpcuaClientEvent } from "../events/model.mjs";
+import { OpcuaConnectError } from "../../OpcuaError.mjs";
+import { ClientLayerOptions } from "../../OpcuaClient.mjs";
+import * as node_opcua0 from "node-opcua";
+import { OPCUAClient } from "node-opcua";
+import { Effect, Stream } from "effect";
+import * as effect_Scope1 from "effect/Scope";
+
+//#region src/internal/client/make.d.ts
+declare const makeClientService: (options: ClientLayerOptions) => Effect.Effect<{
+  events: Stream.Stream<OpcuaClientEvent, never, never>;
+  unsafeRawClient: OPCUAClient<node_opcua0.OPCUAClientBaseEvents>;
+}, OpcuaConnectError, effect_Scope1.Scope>;
+//#endregion
+export { makeClientService };
+//# sourceMappingURL=make.d.mts.map

package/dist/internal/client/make.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"make.d.mts","names":[],"sources":["../../../src/internal/client/make.ts"],"sourcesContent":[],"mappings":";;;;;;;;;cASa,6BAAiB,uBAAA,MAAA,CAAA"}

package/dist/internal/client/make.mjs

@@ -0,0 +1,76 @@
+import { connectError, disconnectError } from "../../OpcuaError.mjs";
+import { EventBus, wireClientEvents } from "../events/wire.mjs";
+import { EVENT_BUFFER_SIZE } from "../common/constants.mjs";
+import { OPCUAClient } from "node-opcua";
+import { Effect, PubSub, Stream } from "effect";
+
+//#region src/internal/client/make.ts
+const makeClientService = Effect.fnUntraced(function* (options) {
+	const events = yield* PubSub.sliding({
+		capacity: EVENT_BUFFER_SIZE,
+		replay: 1
+	});
+	yield* Effect.addFinalizer(() => PubSub.shutdown(events));
+	const unsafeRawClient = yield* Effect.try({
+		try: () => OPCUAClient.create(options.clientOptions ?? {}),
+		catch: (cause) => connectError({
+			endpointUrl: options.endpointUrl,
+			cause
+		})
+	});
+	yield* wireClientEvents(unsafeRawClient, events);
+	yield* Effect.acquireRelease(Effect.tryPromise({
+		try: async (signal) => {
+			let disconnectAfterAbort;
+			const disconnectOnAbort = () => {
+				disconnectAfterAbort ??= unsafeRawClient.disconnect().catch(() => void 0);
+			};
+			signal.addEventListener("abort", disconnectOnAbort, { once: true });
+			try {
+				await unsafeRawClient.connect(options.endpointUrl);
+				if (signal.aborted) {
+					disconnectOnAbort();
+					await disconnectAfterAbort;
+					throw new Error("Connection aborted");
+				}
+				EventBus.publishUnsafe(events, {
+					_tag: "Connected",
+					endpointUrl: options.endpointUrl
+				});
+				return unsafeRawClient;
+			} finally {
+				signal.removeEventListener("abort", disconnectOnAbort);
+			}
+		},
+		catch: (cause) => connectError({
+			endpointUrl: options.endpointUrl,
+			cause
+		})
+	}).pipe(Effect.withSpan("opcua.connect", {
+		attributes: { "opcua.endpoint_url": options.endpointUrl },
+		kind: "client"
+	})), () => Effect.tryPromise({
+		try: async () => {
+			await unsafeRawClient.disconnect();
+			EventBus.publishUnsafe(events, {
+				_tag: "Disconnected",
+				endpointUrl: options.endpointUrl
+			});
+		},
+		catch: (cause) => disconnectError({
+			endpointUrl: options.endpointUrl,
+			cause
+		})
+	}).pipe(Effect.withSpan("opcua.disconnect", {
+		attributes: { "opcua.endpoint_url": options.endpointUrl },
+		kind: "client"
+	}), Effect.ignore));
+	return {
+		events: Stream.fromPubSub(events),
+		unsafeRawClient
+	};
+});
+
+//#endregion
+export { makeClientService };
+//# sourceMappingURL=make.mjs.map

package/dist/internal/client/make.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"make.mjs","names":["OpcuaError.connectError","disconnectAfterAbort: Promise<void> | undefined","OpcuaError.disconnectError"],"sources":["../../../src/internal/client/make.ts"],"sourcesContent":["import { OPCUAClient } from \"node-opcua\";\nimport { Effect, PubSub, Stream } from \"effect\";\n\nimport * as OpcuaError from \"../../OpcuaError.js\";\nimport type { ClientLayerOptions, ClientService } from \"../../OpcuaClient.js\";\nimport { EVENT_BUFFER_SIZE } from \"../common/constants.js\";\nimport { EventBus, wireClientEvents } from \"../events/wire.js\";\nimport type { OpcuaClientEvent } from \"../events/model.js\";\n\nexport const makeClientService = Effect.fnUntraced(function* (\n  options: ClientLayerOptions,\n) {\n  const events = yield* PubSub.sliding<OpcuaClientEvent>({\n    capacity: EVENT_BUFFER_SIZE,\n    replay: 1,\n  });\n  yield* Effect.addFinalizer(() => PubSub.shutdown(events));\n\n  const unsafeRawClient = yield* Effect.try({\n    try: () => OPCUAClient.create(options.clientOptions ?? {}),\n    catch: (cause) =>\n      OpcuaError.connectError({ endpointUrl: options.endpointUrl, cause }),\n  });\n  yield* wireClientEvents(unsafeRawClient, events);\n  yield* Effect.acquireRelease(\n    Effect.tryPromise({\n      try: async (signal) => {\n        let disconnectAfterAbort: Promise<void> | undefined;\n        const disconnectOnAbort = () => {\n          disconnectAfterAbort ??= unsafeRawClient\n            .disconnect()\n            .catch(() => undefined);\n        };\n\n        signal.addEventListener(\"abort\", disconnectOnAbort, { once: true });\n        try {\n          await unsafeRawClient.connect(options.endpointUrl);\n          if (signal.aborted) {\n            disconnectOnAbort();\n            await disconnectAfterAbort;\n            throw new Error(\"Connection aborted\");\n          }\n          EventBus.publishUnsafe(events, {\n            _tag: \"Connected\",\n            endpointUrl: options.endpointUrl,\n          });\n          return unsafeRawClient;\n        } finally {\n          signal.removeEventListener(\"abort\", disconnectOnAbort);\n        }\n      },\n      catch: (cause) =>\n        OpcuaError.connectError({\n          endpointUrl: options.endpointUrl,\n          cause,\n        }),\n    }).pipe(\n      Effect.withSpan(\"opcua.connect\", {\n        attributes: { \"opcua.endpoint_url\": options.endpointUrl },\n        kind: \"client\",\n      }),\n    ),\n    () =>\n      Effect.tryPromise({\n        try: async () => {\n          await unsafeRawClient.disconnect();\n          EventBus.publishUnsafe(events, {\n            _tag: \"Disconnected\",\n            endpointUrl: options.endpointUrl,\n          });\n        },\n        catch: (cause) =>\n          OpcuaError.disconnectError({\n            endpointUrl: options.endpointUrl,\n            cause,\n          }),\n      }).pipe(\n        Effect.withSpan(\"opcua.disconnect\", {\n          attributes: { \"opcua.endpoint_url\": options.endpointUrl },\n          kind: \"client\",\n        }),\n        Effect.ignore,\n      ),\n  );\n  return {\n    events: Stream.fromPubSub(events),\n    unsafeRawClient,\n  } satisfies ClientService;\n});\n"],"mappings":";;;;;;;AASA,MAAa,oBAAoB,OAAO,WAAW,WACjD,SACA;CACA,MAAM,SAAS,OAAO,OAAO,QAA0B;EACrD,UAAU;EACV,QAAQ;EACT,CAAC;AACF,QAAO,OAAO,mBAAmB,OAAO,SAAS,OAAO,CAAC;CAEzD,MAAM,kBAAkB,OAAO,OAAO,IAAI;EACxC,WAAW,YAAY,OAAO,QAAQ,iBAAiB,EAAE,CAAC;EAC1D,QAAQ,UACNA,aAAwB;GAAE,aAAa,QAAQ;GAAa;GAAO,CAAC;EACvE,CAAC;AACF,QAAO,iBAAiB,iBAAiB,OAAO;AAChD,QAAO,OAAO,eACZ,OAAO,WAAW;EAChB,KAAK,OAAO,WAAW;GACrB,IAAIC;GACJ,MAAM,0BAA0B;AAC9B,6BAAyB,gBACtB,YAAY,CACZ,YAAY,OAAU;;AAG3B,UAAO,iBAAiB,SAAS,mBAAmB,EAAE,MAAM,MAAM,CAAC;AACnE,OAAI;AACF,UAAM,gBAAgB,QAAQ,QAAQ,YAAY;AAClD,QAAI,OAAO,SAAS;AAClB,wBAAmB;AACnB,WAAM;AACN,WAAM,IAAI,MAAM,qBAAqB;;AAEvC,aAAS,cAAc,QAAQ;KAC7B,MAAM;KACN,aAAa,QAAQ;KACtB,CAAC;AACF,WAAO;aACC;AACR,WAAO,oBAAoB,SAAS,kBAAkB;;;EAG1D,QAAQ,UACND,aAAwB;GACtB,aAAa,QAAQ;GACrB;GACD,CAAC;EACL,CAAC,CAAC,KACD,OAAO,SAAS,iBAAiB;EAC/B,YAAY,EAAE,sBAAsB,QAAQ,aAAa;EACzD,MAAM;EACP,CAAC,CACH,QAEC,OAAO,WAAW;EAChB,KAAK,YAAY;AACf,SAAM,gBAAgB,YAAY;AAClC,YAAS,cAAc,QAAQ;IAC7B,MAAM;IACN,aAAa,QAAQ;IACtB,CAAC;;EAEJ,QAAQ,UACNE,gBAA2B;GACzB,aAAa,QAAQ;GACrB;GACD,CAAC;EACL,CAAC,CAAC,KACD,OAAO,SAAS,oBAAoB;EAClC,YAAY,EAAE,sBAAsB,QAAQ,aAAa;EACzD,MAAM;EACP,CAAC,EACF,OAAO,OACR,CACJ;AACD,QAAO;EACL,QAAQ,OAAO,WAAW,OAAO;EACjC;EACD;EACD"}

package/dist/internal/common/collections.d.mts

@@ -0,0 +1,5 @@
+//#region src/internal/common/collections.d.ts
+declare const chunksOf: <A>(items: ReadonlyArray<A>, size: number) => ReadonlyArray<ReadonlyArray<A>>;
+//#endregion
+export { chunksOf };
+//# sourceMappingURL=collections.d.mts.map

package/dist/internal/common/collections.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collections.d.mts","names":[],"sources":["../../../src/internal/common/collections.ts"],"sourcesContent":[],"mappings":";cAAa,qBACJ,cAAc,qBAEpB,cAAc,cAAc"}

package/dist/internal/common/collections.mjs

@@ -0,0 +1,10 @@
+//#region src/internal/common/collections.ts
+const chunksOf = (items, size) => {
+	const chunks = [];
+	for (let index = 0; index < items.length; index += size) chunks.push(items.slice(index, index + size));
+	return chunks;
+};
+
+//#endregion
+export { chunksOf };
+//# sourceMappingURL=collections.mjs.map

package/dist/internal/common/collections.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"collections.mjs","names":["chunks: Array<ReadonlyArray<A>>"],"sources":["../../../src/internal/common/collections.ts"],"sourcesContent":["export const chunksOf = <A>(\n  items: ReadonlyArray<A>,\n  size: number,\n): ReadonlyArray<ReadonlyArray<A>> => {\n  const chunks: Array<ReadonlyArray<A>> = [];\n  for (let index = 0; index < items.length; index += size) {\n    chunks.push(items.slice(index, index + size));\n  }\n  return chunks;\n};\n"],"mappings":";AAAA,MAAa,YACX,OACA,SACoC;CACpC,MAAMA,SAAkC,EAAE;AAC1C,MAAK,IAAI,QAAQ,GAAG,QAAQ,MAAM,QAAQ,SAAS,KACjD,QAAO,KAAK,MAAM,MAAM,OAAO,QAAQ,KAAK,CAAC;AAE/C,QAAO"}

package/dist/internal/common/constants.d.mts

@@ -0,0 +1,18 @@
+import * as node_opcua1 from "node-opcua";
+
+//#region src/internal/common/constants.d.ts
+declare const EVENT_BUFFER_SIZE = 256;
+declare const DEFAULT_LIFETIME_COUNT = 60;
+declare const DEFAULT_MAX_KEEP_ALIVE_COUNT = 10;
+declare const DEFAULT_MAX_NOTIFICATIONS_PER_PUBLISH = 0;
+declare const DEFAULT_PUBLISHING_ENABLED = true;
+declare const DEFAULT_PRIORITY = 0;
+declare const DEFAULT_BROWSE_REFERENCE_TYPE_ID = "HierarchicalReferences";
+declare const DEFAULT_BROWSE_DIRECTION = BrowseDirection.Forward;
+declare const DEFAULT_BROWSE_INCLUDE_SUBTYPES = true;
+declare const DEFAULT_BROWSE_NODE_CLASS_MASK = 0;
+declare const DEFAULT_BROWSE_RESULT_MASK: node_opcua1.ResultMask;
+declare const DEFAULT_BROWSE_MAX_REFERENCES_PER_NODE = 0;
+//#endregion
+export { DEFAULT_BROWSE_DIRECTION, DEFAULT_BROWSE_INCLUDE_SUBTYPES, DEFAULT_BROWSE_MAX_REFERENCES_PER_NODE, DEFAULT_BROWSE_NODE_CLASS_MASK, DEFAULT_BROWSE_REFERENCE_TYPE_ID, DEFAULT_BROWSE_RESULT_MASK, DEFAULT_LIFETIME_COUNT, DEFAULT_MAX_KEEP_ALIVE_COUNT, DEFAULT_MAX_NOTIFICATIONS_PER_PUBLISH, DEFAULT_PRIORITY, DEFAULT_PUBLISHING_ENABLED, EVENT_BUFFER_SIZE };
+//# sourceMappingURL=constants.d.mts.map

package/dist/internal/common/constants.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.mts","names":[],"sources":["../../../src/internal/common/constants.ts"],"sourcesContent":[],"mappings":";;;cAEa,iBAAA;cACA,sBAAA;AADA,cAEA,4BAAA,GAFiB,EAAA;AACjB,cAEA,qCAAA,GAFsB,CAAA;AACtB,cAEA,0BAAA,GAF4B,IAAA;AAC5B,cAEA,gBAAA,GAFA,CAAA;AACA,cAEA,gCAAA,GAF0B,wBAAA;AAC1B,cAEA,wBAAA,GAFgB,eAAA,CAAA,OAAA;AAChB,cAEA,+BAAA,GAFgC,IAAA;AAChC,cAEA,8BAAA,GAFwB,CAAA;AACxB,cAEA,0BAF+B,EAI3C,WAAA,CAFsC,UAFK;AAC/B,cAIA,sCAAA,GAJ8B,CAAA"}

package/dist/internal/common/constants.mjs

@@ -0,0 +1,19 @@
+import { BrowseDirection, makeResultMask } from "node-opcua";
+
+//#region src/internal/common/constants.ts
+const EVENT_BUFFER_SIZE = 256;
+const DEFAULT_LIFETIME_COUNT = 60;
+const DEFAULT_MAX_KEEP_ALIVE_COUNT = 10;
+const DEFAULT_MAX_NOTIFICATIONS_PER_PUBLISH = 0;
+const DEFAULT_PUBLISHING_ENABLED = true;
+const DEFAULT_PRIORITY = 0;
+const DEFAULT_BROWSE_REFERENCE_TYPE_ID = "HierarchicalReferences";
+const DEFAULT_BROWSE_DIRECTION = BrowseDirection.Forward;
+const DEFAULT_BROWSE_INCLUDE_SUBTYPES = true;
+const DEFAULT_BROWSE_NODE_CLASS_MASK = 0;
+const DEFAULT_BROWSE_RESULT_MASK = makeResultMask("ReferenceType | IsForward | NodeClass | BrowseName | DisplayName | TypeDefinition");
+const DEFAULT_BROWSE_MAX_REFERENCES_PER_NODE = 0;
+
+//#endregion
+export { DEFAULT_BROWSE_DIRECTION, DEFAULT_BROWSE_INCLUDE_SUBTYPES, DEFAULT_BROWSE_MAX_REFERENCES_PER_NODE, DEFAULT_BROWSE_NODE_CLASS_MASK, DEFAULT_BROWSE_REFERENCE_TYPE_ID, DEFAULT_BROWSE_RESULT_MASK, DEFAULT_LIFETIME_COUNT, DEFAULT_MAX_KEEP_ALIVE_COUNT, DEFAULT_MAX_NOTIFICATIONS_PER_PUBLISH, DEFAULT_PRIORITY, DEFAULT_PUBLISHING_ENABLED, EVENT_BUFFER_SIZE };
+//# sourceMappingURL=constants.mjs.map

package/dist/internal/common/constants.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.mjs","names":[],"sources":["../../../src/internal/common/constants.ts"],"sourcesContent":["import { BrowseDirection, makeResultMask } from \"node-opcua\";\n\nexport const EVENT_BUFFER_SIZE = 256;\nexport const DEFAULT_LIFETIME_COUNT = 60;\nexport const DEFAULT_MAX_KEEP_ALIVE_COUNT = 10;\nexport const DEFAULT_MAX_NOTIFICATIONS_PER_PUBLISH = 0;\nexport const DEFAULT_PUBLISHING_ENABLED = true;\nexport const DEFAULT_PRIORITY = 0;\nexport const DEFAULT_BROWSE_REFERENCE_TYPE_ID = \"HierarchicalReferences\";\nexport const DEFAULT_BROWSE_DIRECTION = BrowseDirection.Forward;\nexport const DEFAULT_BROWSE_INCLUDE_SUBTYPES = true;\nexport const DEFAULT_BROWSE_NODE_CLASS_MASK = 0;\nexport const DEFAULT_BROWSE_RESULT_MASK = makeResultMask(\n  \"ReferenceType | IsForward | NodeClass | BrowseName | DisplayName | TypeDefinition\",\n);\nexport const DEFAULT_BROWSE_MAX_REFERENCES_PER_NODE = 0;\n"],"mappings":";;;AAEA,MAAa,oBAAoB;AACjC,MAAa,yBAAyB;AACtC,MAAa,+BAA+B;AAC5C,MAAa,wCAAwC;AACrD,MAAa,6BAA6B;AAC1C,MAAa,mBAAmB;AAChC,MAAa,mCAAmC;AAChD,MAAa,2BAA2B,gBAAgB;AACxD,MAAa,kCAAkC;AAC/C,MAAa,iCAAiC;AAC9C,MAAa,6BAA6B,eACxC,oFACD;AACD,MAAa,yCAAyC"}

package/dist/internal/common/node-id.d.mts

@@ -0,0 +1,2 @@
+import { ExpandedNodeIdString, NodeIdString, VariableCapability } from "../../OpcuaVariable.mjs";
+export { type ExpandedNodeIdString, type NodeIdString, type VariableCapability };

package/dist/internal/common/node-id.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/internal/common/options.d.mts

@@ -0,0 +1,15 @@
+import { Duration } from "effect";
+
+//#region src/internal/common/options.d.ts
+declare const unknownKeys: (value: Record<string, unknown>, allowedKeys: Iterable<string>) => ReadonlyArray<string>;
+declare const positiveIntegerOption: (value: unknown) => value is number;
+declare const nonNegativeIntegerOption: (value: unknown) => value is number;
+declare const positiveIntegerOrDefault: (value: number | undefined, fallback: number) => number;
+declare const durationToMillis: (duration: Duration.Duration, options: {
+  readonly notDuration: string;
+  readonly invalidDuration: string;
+}) => string | number;
+declare const stringUnionOption: <Value extends string>(value: unknown, allowed: ReadonlyArray<Value>) => value is Value;
+//#endregion
+export { durationToMillis, nonNegativeIntegerOption, positiveIntegerOption, positiveIntegerOrDefault, stringUnionOption, unknownKeys };
+//# sourceMappingURL=options.d.mts.map

package/dist/internal/common/options.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.mts","names":[],"sources":["../../../src/internal/common/options.ts"],"sourcesContent":[],"mappings":";;;cAIa,qBACJ,sCACM,qBACZ;cAKU;AARA,cAWA,wBALZ,EAAA,CAAA,KAAA,EAAA,OAAA,EAAA,GAAA,KAAA,IAAA,MAAA;AALQ,cAaI,wBAbJ,EAAA,CAAA,KAAA,EAAA,MAAA,GAAA,SAAA,EAAA,QAAA,EAAA,MAAA,EAAA,GAAA,MAAA;AACM,cAiBF,gBAjBE,EAAA,CAAA,QAAA,EAkBH,QAAA,CAAS,QAlBN,EAAA,OAAA,EAAA;EACZ,SAAA,WAAA,EAAA,MAAA;EAAa,SAAA,eAAA,EAAA,MAAA;AAKhB,CAAA,EAAA,GAAa,MAAA,GAAA,MAAA;AAGA,cAqBA,iBApBc,EAAA,CAAA,cAAA,MAAA,CAAA,CAAA,KAAA,EAAA,OAAA,EAAA,OAAA,EAsBhB,aAtBgB,CAsBF,KAtBE,CAAA,EAAA,GAAA,KAAA,IAuBf,KAvBe"}

package/dist/internal/common/options.mjs

@@ -0,0 +1,22 @@
+import { nonNegativeInteger, positiveInteger } from "./predicates.mjs";
+import { Duration } from "effect";
+
+//#region src/internal/common/options.ts
+const unknownKeys = (value, allowedKeys) => {
+	const allowed = new Set(allowedKeys);
+	return Object.keys(value).filter((key) => !allowed.has(key));
+};
+const positiveIntegerOption = (value) => positiveInteger(value);
+const nonNegativeIntegerOption = (value) => nonNegativeInteger(value);
+const positiveIntegerOrDefault = (value, fallback) => positiveInteger(value) ? Math.floor(value) : fallback;
+const durationToMillis = (duration, options) => {
+	if (!Duration.isDuration(duration)) return options.notDuration;
+	const millis = Duration.toMillis(duration);
+	if (!Number.isFinite(millis) || millis < 0) return options.invalidDuration;
+	return millis;
+};
+const stringUnionOption = (value, allowed) => allowed.includes(value);
+
+//#endregion
+export { durationToMillis, nonNegativeIntegerOption, positiveIntegerOption, positiveIntegerOrDefault, stringUnionOption, unknownKeys };
+//# sourceMappingURL=options.mjs.map

package/dist/internal/common/options.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.mjs","names":[],"sources":["../../../src/internal/common/options.ts"],"sourcesContent":["import { Duration } from \"effect\";\n\nimport { nonNegativeInteger, positiveInteger } from \"./predicates.js\";\n\nexport const unknownKeys = (\n  value: Record<string, unknown>,\n  allowedKeys: Iterable<string>,\n): ReadonlyArray<string> => {\n  const allowed = new Set(allowedKeys);\n  return Object.keys(value).filter((key) => !allowed.has(key));\n};\n\nexport const positiveIntegerOption = (value: unknown): value is number =>\n  positiveInteger(value);\n\nexport const nonNegativeIntegerOption = (value: unknown): value is number =>\n  nonNegativeInteger(value);\n\nexport const positiveIntegerOrDefault = (\n  value: number | undefined,\n  fallback: number,\n) => (positiveInteger(value) ? Math.floor(value) : fallback);\n\nexport const durationToMillis = (\n  duration: Duration.Duration,\n  options: {\n    readonly notDuration: string;\n    readonly invalidDuration: string;\n  },\n) => {\n  if (!Duration.isDuration(duration)) return options.notDuration;\n  const millis = Duration.toMillis(duration);\n  if (!Number.isFinite(millis) || millis < 0) return options.invalidDuration;\n  return millis;\n};\n\nexport const stringUnionOption = <Value extends string>(\n  value: unknown,\n  allowed: ReadonlyArray<Value>,\n): value is Value => allowed.includes(value as Value);\n"],"mappings":";;;;AAIA,MAAa,eACX,OACA,gBAC0B;CAC1B,MAAM,UAAU,IAAI,IAAI,YAAY;AACpC,QAAO,OAAO,KAAK,MAAM,CAAC,QAAQ,QAAQ,CAAC,QAAQ,IAAI,IAAI,CAAC;;AAG9D,MAAa,yBAAyB,UACpC,gBAAgB,MAAM;AAExB,MAAa,4BAA4B,UACvC,mBAAmB,MAAM;AAE3B,MAAa,4BACX,OACA,aACI,gBAAgB,MAAM,GAAG,KAAK,MAAM,MAAM,GAAG;AAEnD,MAAa,oBACX,UACA,YAIG;AACH,KAAI,CAAC,SAAS,WAAW,SAAS,CAAE,QAAO,QAAQ;CACnD,MAAM,SAAS,SAAS,SAAS,SAAS;AAC1C,KAAI,CAAC,OAAO,SAAS,OAAO,IAAI,SAAS,EAAG,QAAO,QAAQ;AAC3D,QAAO;;AAGT,MAAa,qBACX,OACA,YACmB,QAAQ,SAAS,MAAe"}

package/dist/internal/common/predicates.d.mts

@@ -0,0 +1,8 @@
+//#region src/internal/common/predicates.d.ts
+declare const isRecord: (value: unknown) => value is Record<string, unknown>;
+declare const isPlainRecord: (value: unknown) => value is Record<string, unknown>;
+declare const positiveInteger: (value: unknown) => value is number;
+declare const nonNegativeInteger: (value: unknown) => value is number;
+//#endregion
+export { isPlainRecord, isRecord, nonNegativeInteger, positiveInteger };
+//# sourceMappingURL=predicates.d.mts.map

package/dist/internal/common/predicates.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"predicates.d.mts","names":[],"sources":["../../../src/internal/common/predicates.ts"],"sourcesContent":[],"mappings":";cAAa,uCAAsC;AAAtC,cAGA,aAHsC,EAAM,CAAA,KAAA,EAAA,OAAA,EAAA,GAAA,KAAA,IAK7C,MAL6C,CAAA,MAAA,EAAA,OAAA,CAAA;AAG5C,cAQA,eAND,EAAA,CAAA,KAAM,EAAA,OAAA,EAAA,GAAA,KAAA,IAAA,MAAA;AAML,cAMA,kBAFF,EAAA,CAAA,KAAA,EAAA,OAAA,EAAA,GAAA,KAAA,IAAA,MAAA"}