@syncbridge/common 0.10.3 → 0.12.0

package/classes/base-element.d.ts

@@ -1,4 +1,4 @@
-import { ILogger } from '../interfaces/index.js';
+import type { ILogger } from '../interfaces/index.js';
 import { ServiceStatus } from '../models/index.js';
 import type { ComponentBase } from './component-base.js';
 import { Runnable } from './runnable.js';

package/classes/console-logger.d.ts

@@ -1,4 +1,4 @@
-import { ILogger } from '../interfaces/index.js';
+import type { ILogger } from '../interfaces/index.js';
 export declare class ConsoleLogger implements ILogger {
     level: string;
     critical(...args: any[]): ILogger;

package/classes/console-logger.js

@@ -21,7 +21,7 @@ export class ConsoleLogger {
         return this;
     }
     trace(...args) {
-        console.trace(...args);
+        console.info(...args);
         return this;
     }
     warn(...args) {

package/classes/frame-stream.d.ts

@@ -1,7 +1,7 @@
 import { Buffer } from 'node:buffer';
 import { Transform } from 'node:stream';
-import { TransformCallback, TransformOptions } from 'stream';
-import { StrictOmit } from 'ts-gems';
+import type { TransformCallback, TransformOptions } from 'stream';
+import type { StrictOmit } from 'ts-gems';
 export declare class FrameStream extends Transform {
     private _chunks;
     private _chunkBuffer?;

package/classes/runnable.d.ts

@@ -1,4 +1,4 @@
-import { AsyncEventEmitter, EventMap } from 'node-events-async';
+import { AsyncEventEmitter, type EventMap } from 'node-events-async';
 import { ServiceStatus } from '../models/index.js';
 /**
  *

package/classes/sb-error.d.ts

@@ -1,4 +1,4 @@
-import { ErrorIssue } from '@opra/common';
+import type { ErrorIssue } from '@opra/common';
 export declare class SbError extends Error implements ErrorIssue {
     readonly cause?: Error;
     severity: ErrorIssue['severity'];

package/classes/stack-executor.d.ts

@@ -1,10 +1,10 @@
-import { ErrorIssue } from '@opra/common';
+import type { ErrorIssue } from '@opra/common';
 type NotPromise<T> = T extends Promise<any> ? never : T;
 export declare class StackExecutor {
     stack: string[];
     issues: StackExecutor.Issue[];
-    executeAsync(stack: string, fn: () => Promise<any>): Promise<void>;
-    execute<T>(stack: string, fn: () => NotPromise<T>): void;
+    executeAsync(stack: string, fn: () => Promise<any>): Promise<boolean>;
+    execute<T>(stack: string, fn: () => NotPromise<T>): boolean;
     handleError(e: any): void;
 }
 export declare namespace StackExecutor {

package/classes/stack-executor.js

@@ -14,6 +14,7 @@ export class StackExecutor {
         finally {
             this.stack.pop();
         }
+        return !this.issues.find(i => !(i.severity === 'warning' || i.severity === 'info'));
     }
     execute(stack, fn) {
         this.stack.push(stack);
@@ -26,6 +27,7 @@ export class StackExecutor {
         finally {
             this.stack.pop();
         }
+        return !this.issues.find(i => !(i.severity === 'warning' || i.severity === 'info'));
     }
     handleError(e) {
         const location = this.stack.join('/');

package/constants.js

@@ -1,4 +1,4 @@
-export const version = '0.10.3';
+export const version = '0.12.0';
 export const CLASS_METADATA = Symbol.for('CLASS_METADATA');
 export const CLASS_TYPE = Symbol.for('CLASS_TYPE');
 export const VARIABLE_CONTAINER = Symbol.for('VARIABLE_CONTAINER');

package/decorators/component.decorator.d.ts

@@ -1,5 +1,5 @@
 import 'reflect-metadata';
-import { DeepPartial, StrictOmit, Type } from 'ts-gems';
+import type { DeepPartial, StrictOmit, Type } from 'ts-gems';
 import { ComponentBase } from '../classes/component-base.js';
 import { ComponentMetadata } from '../models/index.js';
 import { UseComponent as _UseComponent } from './use-component.decorator.js';

package/decorators/component.decorator.js

@@ -2,12 +2,14 @@ import 'reflect-metadata';
 import path from 'node:path';
 import { omit } from '@jsopen/objects';
 import callerCallsite from 'caller-callsite';
+import { ComponentBase } from '../classes/component-base.js';
 import { CLASS_METADATA, CLASS_TYPE } from '../constants.js';
+import { ComponentMetadata } from '../models/index.js';
 import { resolvePackageJson } from '../utils/locate-package-json.js';
 import { defineOwnMetadata, parseNpmAuthor } from './decorator-helpers.js';
 import { UseComponent as _UseComponent } from './use-component.decorator.js';
 import { UseVariables as _UseVariables } from './use-variables.decorator.js';
-const NAME_PATTERN = /^(.*?)(Component)?$/;
+const NAME_PATTERN = /^([A-Z][A-Za-z0-9_]*?)(Component)?$/;
 export function Component(options) {
     const callerFile = callerCallsite()?.getFileName();
     const pkgjson = callerFile && resolvePackageJson(path.dirname(callerFile));

package/decorators/define-variable.decorator.d.ts

@@ -1,7 +1,7 @@
 import 'reflect-metadata';
-import { DeepPartial, StrictOmit, Type } from 'ts-gems';
+import type { DeepPartial, StrictOmit, Type } from 'ts-gems';
 import { VariableMetadata, VariableMetadataRecord } from '../models/index.js';
-export declare function DefineVariable(options: DefineVariable.Options): (target: Object, propertyKey: string | symbol) => void;
+export declare function DefineVariable(options?: DefineVariable.Options): (target: Object, propertyKey: string | symbol) => void;
 type TEnumValue = (string | number)[] | Record<string, string | number>;
 type TVariable = DeepPartial<VariableMetadataRecord> | Type;
 export declare namespace DefineVariable {

package/decorators/define-variable.decorator.js

@@ -1,8 +1,8 @@
 import 'reflect-metadata';
 import { deepClone, merge, omitUndefined } from '@jsopen/objects';
 import { VARIABLE_CONTAINER } from '../constants.js';
-import { VariableType, } from '../models/index.js';
-export function DefineVariable(options) {
+import { VariableMetadata, VariableMetadataRecord, VariableType, } from '../models/index.js';
+export function DefineVariable(options = {}) {
     return function (target, propertyKey) {
         /** c8 ignore next */
         if (typeof propertyKey !== 'string')
@@ -36,6 +36,8 @@ export function DefineVariable(options) {
                 metadata.type = VariableType.Boolean;
             else if (designType === Number)
                 metadata.type = VariableType.Number;
+            else if (designType === BigInt)
+                metadata.type = VariableType.BigInt;
             else if (typeof designType === 'function' &&
                 Reflect.hasMetadata(VARIABLE_CONTAINER, designType.prototype)) {
                 metadata.type = VariableType.Nested;

package/decorators/processor-events.decorator.d.ts

@@ -1,5 +1,5 @@
 import 'reflect-metadata';
-import { Type } from 'ts-gems';
+import type { Type } from 'ts-gems';
 import type { ProcessorBase } from '../classes/processor-base.js';
 export declare function OnCreateProfile<T extends Type<ProcessorBase>>(): (target: T, propertyKey: string | symbol) => void;
 export declare function OnUpdateProfile<T extends Type<ProcessorBase>>(): (target: T, propertyKey: string | symbol) => void;

package/decorators/processor.decorator.d.ts

@@ -1,9 +1,9 @@
 import 'reflect-metadata';
-import { DeepPartial, StrictOmit, Type } from 'ts-gems';
+import type { DeepPartial, StrictOmit, Type } from 'ts-gems';
 import type { ProcessorBase } from '../classes/processor-base.js';
 import { ProcessorMetadata } from '../models/index.js';
 import { UseComponent as _UseComponent } from './use-component.decorator.js';
-export declare function Processor<T extends ProcessorBase>(options: Processor.Options): (target: Type<T>) => void;
+export declare function Processor<T extends ProcessorBase>(options?: Processor.Options): (target: Type<T>) => void;
 export declare namespace Processor {
     /**
      *

package/decorators/processor.decorator.js

@@ -3,12 +3,13 @@ import path from 'node:path';
 import { omit } from '@jsopen/objects';
 import callerCallsite from 'caller-callsite';
 import { CLASS_METADATA, CLASS_TYPE } from '../constants.js';
+import { ProcessorMetadata } from '../models/index.js';
 import { resolvePackageJson } from '../utils/locate-package-json.js';
 import { defineOwnMetadata } from './decorator-helpers.js';
 import { OnCreateProfile as _OnCreateProfile, OnUpdateProfile as _OnUpdateProfile, } from './processor-events.decorator.js';
 import { UseComponent as _UseComponent } from './use-component.decorator.js';
 import { UseVariables as _UseVariables } from './use-variables.decorator.js';
-const NAME_PATTERN = /^(.*?)(Processor)?$/;
+const NAME_PATTERN = /^([A-Z][A-Za-z0-9_]*)(Processor)?$/;
 export function Processor(options) {
     const callerFile = callerCallsite()?.getFileName();
     const pkgjson = callerFile && resolvePackageJson(path.dirname(callerFile));
@@ -19,7 +20,7 @@ export function Processor(options) {
         if (classType && classType !== 'processor')
             throw new TypeError(`${target.name} already decorated as "${classType}"`);
         /** Determine class name */
-        let className = options.className;
+        let className = options?.className;
         if (!className) {
             const m = NAME_PATTERN.exec(target.name);
             if (!m)
@@ -38,7 +39,7 @@ export function Processor(options) {
             uri,
             displayName: className,
             version: pkgjson.version,
-            abstract: !!options.abstract,
+            abstract: !!options?.abstract,
             ...omit(options, ['uri', 'components', 'variables', 'version']),
         });
         target.uri = uri;

package/decorators/use-component.decorator.d.ts

@@ -1,5 +1,5 @@
 import 'reflect-metadata';
-import { StrictOmit } from 'ts-gems';
+import type { StrictOmit } from 'ts-gems';
 import { ComponentBase } from '../classes/component-base.js';
 import { ProcessorBase } from '../classes/processor-base.js';
 import { ElementComponentMetadata } from '../models/index.js';

package/decorators/use-component.decorator.js

@@ -1,6 +1,9 @@
 import 'reflect-metadata';
 import { omit } from '@jsopen/objects';
+import { ComponentBase } from '../classes/component-base.js';
+import { ProcessorBase } from '../classes/processor-base.js';
 import { CLASS_METADATA } from '../constants.js';
+import { ElementComponentMetadata } from '../models/index.js';
 import { defineOwnMetadata } from './decorator-helpers.js';
 export function UseComponent(options = {}) {
     return function (target, propertyKey) {

package/index.d.ts

@@ -20,5 +20,5 @@ export * from './registry/extension-registry.js';
 export * from './utils/decode-profile.js';
 export * from './utils/materialize-metadata.js';
 export * from './utils/normalize-metadata.js';
-export * from './utils/type-guartds.js';
+export * from './utils/type-guards.js';
 export * from './utils/uri-to-id.js';

package/index.js

@@ -20,5 +20,5 @@ export * from './registry/extension-registry.js';
 export * from './utils/decode-profile.js';
 export * from './utils/materialize-metadata.js';
 export * from './utils/normalize-metadata.js';
-export * from './utils/type-guartds.js';
+export * from './utils/type-guards.js';
 export * from './utils/uri-to-id.js';

package/models/enums/variable-type.enum.d.ts

@@ -2,6 +2,7 @@ export declare enum VariableType {
     String = "string",
     Secret = "secret",
     Number = "number",
+    BigInt = "bigint",
     Boolean = "boolean",
     Nested = "nested",
     Enum = "enum"

package/models/enums/variable-type.enum.js

@@ -4,6 +4,7 @@ export var VariableType;
     VariableType["String"] = "string";
     VariableType["Secret"] = "secret";
     VariableType["Number"] = "number";
+    VariableType["BigInt"] = "bigint";
     VariableType["Boolean"] = "boolean";
     VariableType["Nested"] = "nested";
     VariableType["Enum"] = "enum";

package/models-document.js

@@ -1,4 +1,4 @@
-import { ApiDocumentFactory } from '@opra/common';
+import { ApiDocument, ApiDocumentFactory } from '@opra/common';
 import { SbError } from './classes/sb-error.js';
 import * as models from './models/index.js';
 let doc;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syncbridge/common",
-  "version": "0.10.3",
+  "version": "0.12.0",
   "description": "SyncBridge Common utilities",
   "author": "Panates Inc",
   "license": "MIT",
@@ -10,9 +10,9 @@
     "node-events-async": "^1.5.2",
     "caller-callsite": "^6.0.0",
     "reflect-metadata": "^0.2.2",
-    "semver": "^7.7.4",
-    "ts-gems": "^3.11.6",
-    "valgen": "^6.0.3"
+    "semver": "^7.8.0",
+    "ts-gems": "^3.12.0",
+    "valgen": "^6.1.0"
   },
   "peerDependencies": {
     "@opra/common": ">=1.17.1 <2"

package/processor-factory.d.ts

@@ -1,6 +1,6 @@
 import { ProcessorBase } from './classes/processor-base.js';
 import { StackExecutor } from './classes/stack-executor.js';
-import { ILogger } from './interfaces/index.js';
+import type { ILogger } from './interfaces/index.js';
 import { Profile } from './models/index.js';
 export declare namespace ProcessorFactory {
     const METADATA_KEY: unique symbol;
@@ -11,10 +11,16 @@ export declare namespace ProcessorFactory {
     }
     function createProcessor<T extends ProcessorBase>(profile: Profile, options?: ProcessorOptions): Promise<T>;
     function createProcessorSilent<T extends ProcessorBase>(profile: Profile, options?: ProcessorOptions): Promise<{
+        result: true;
         processor: T;
         issues: StackExecutor.Issue[];
+    } | {
+        result: false;
+        issues: StackExecutor.Issue[];
     }>;
-    function updateProcessor(processor: ProcessorBase, profile: Profile, options?: ProcessorOptions): Promise<{
+    function updateProcessor(processor: ProcessorBase, profile: Profile, options?: ProcessorOptions): Promise<void>;
+    function updateProcessorSilent(processor: ProcessorBase, profile: Profile, options?: ProcessorOptions): Promise<{
+        result: boolean;
         issues: StackExecutor.Issue[];
     }>;
 }

package/processor-factory.js

@@ -1,56 +1,91 @@
+import { clone } from '@jsopen/objects';
 import equal from 'fast-deep-equal';
+import { ComponentBase } from './classes/component-base.js';
+import { ProcessorBase } from './classes/processor-base.js';
 import { SbError, SbValidationError } from './classes/sb-error.js';
 import { StackExecutor } from './classes/stack-executor.js';
+import { ElementComponentMetadataRecord, ProcessorMetadata, Profile, ProfileComponentRecord, VariableMetadataRecord, } from './models/index.js';
 import { initializeModelsDocument } from './models-document.js';
 import { ExtensionRegistry } from './registry/extension-registry.js';
-import { materializeMetadata } from './utils/materialize-metadata.js';
+import { decodeProfile } from './utils/decode-profile.js';
+import { materializeMetadataSilent } from './utils/materialize-metadata.js';
 export var ProcessorFactory;
 (function (ProcessorFactory) {
     ProcessorFactory.METADATA_KEY = Symbol('METADATA');
     ProcessorFactory.PROFILE_KEY = Symbol('PROFILE');
     async function createProcessor(profile, options) {
-        const { processor: out, issues } = await createProcessorSilent(profile, options);
-        if (issues?.length) {
+        const r1 = await createProcessorSilent(profile, options);
+        if (!r1.result) {
             const msg = 'Error while creating processor.\n  ' +
-                issues
+                r1.issues
                     .map(issue => `- ${issue.message}. Location: /${issue.location}`)
                     .join('\n  ');
-            issues.forEach(issue => {
+            r1.issues.forEach(issue => {
                 if (issue instanceof SbValidationError)
                     delete issue.stack;
             });
             throw new SbValidationError(msg, {
-                issues,
+                issues: r1.issues,
             });
         }
-        return out;
+        return r1.processor;
     }
     ProcessorFactory.createProcessor = createProcessor;
     async function createProcessorSilent(profile, options) {
-        await initializeModelsDocument();
-        const reg = ExtensionRegistry.getProcessor(profile.processorUri, profile.processorVersion);
-        const processorClass = await reg.getClass();
-        const processor = new processorClass({
-            name: profile.displayName,
-            logger: options?.logger,
-            values: profile.values || {},
-            dataDirectory: options?.dataDirectory,
-        });
         const ctx = {
             stackExecutor: new StackExecutor(),
-            processor,
+            processor: undefined,
             profile,
             options,
-            valueUpdates: new Map(),
-        };
-        await _configureProcessor(ctx);
-        return {
-            processor: processor,
-            issues: ctx.stackExecutor.issues,
         };
+        try {
+            await initializeModelsDocument();
+            if (!(await _configureProcessor(ctx))) {
+                return {
+                    result: false,
+                    issues: ctx.stackExecutor.issues,
+                };
+            }
+            return {
+                result: true,
+                processor: ctx.processor,
+                issues: ctx.stackExecutor.issues,
+            };
+        }
+        catch (error) {
+            return {
+                result: false,
+                issues: [
+                    ...ctx.stackExecutor.issues,
+                    {
+                        message: error.message,
+                        type: 'error',
+                        severity: 'error',
+                        stack: error.stack,
+                    },
+                ],
+            };
+        }
     }
     ProcessorFactory.createProcessorSilent = createProcessorSilent;
     async function updateProcessor(processor, profile, options) {
+        const r1 = await updateProcessorSilent(processor, profile, options);
+        if (!r1.result) {
+            const msg = 'Error while updating processor.\n  ' +
+                r1.issues
+                    .map(issue => `- ${issue.message}. Location: /${issue.location}`)
+                    .join('\n  ');
+            r1.issues.forEach(issue => {
+                if (issue instanceof SbValidationError)
+                    delete issue.stack;
+            });
+            throw new SbValidationError(msg, {
+                issues: r1.issues,
+            });
+        }
+    }
+    ProcessorFactory.updateProcessor = updateProcessor;
+    async function updateProcessorSilent(processor, profile, options) {
         if (options?.logger)
             processor.logger = options.logger;
         if (options?.dataDirectory)
@@ -62,47 +97,82 @@ export var ProcessorFactory;
             options,
             valueUpdates: new Map(),
         };
-        await _configureProcessor(ctx);
+        if (!(await _configureProcessor(ctx))) {
+            return {
+                result: false,
+                issues: ctx.stackExecutor.issues,
+            };
+        }
         const signalUpdates = async (obj) => {
             if (obj.components) {
                 for (const component of Object.values(obj.components)) {
                     await signalUpdates(component);
                 }
             }
-            const properties = ctx.valueUpdates.get(obj);
+            const properties = ctx.valueUpdates?.get(obj);
             if (properties?.length) {
                 await obj.emitAsyncSafe('values-updated', properties);
             }
         };
         await signalUpdates(processor);
         return {
+            result: true,
             issues: ctx.stackExecutor.issues,
         };
     }
-    ProcessorFactory.updateProcessor = updateProcessor;
+    ProcessorFactory.updateProcessorSilent = updateProcessorSilent;
     async function _configureProcessor(ctx) {
-        const { processor, profile } = ctx;
-        const newMetadata = materializeMetadata(profile);
+        const r1 = materializeMetadataSilent(ctx.profile);
+        if (!r1.result) {
+            ctx.stackExecutor.issues.push(...r1.issues);
+            return false;
+        }
+        /* Decode profile */
+        const profile = decodeProfile(r1.metadata, ctx.profile);
+        ctx.profile = profile;
+        const oldMetadata = ctx.processor?.[ProcessorFactory.METADATA_KEY];
+        const oldProfile = ctx.processor?.[ProcessorFactory.PROFILE_KEY];
+        if (!ctx.processor) {
+            /* Create new processor instance */
+            const reg = ExtensionRegistry.getProcessor(profile.processorUri, profile.processorVersion);
+            const processorClass = await reg.getClass();
+            /* Create processor instance */
+            ctx.processor = new processorClass({
+                name: profile.displayName,
+                logger: ctx.options?.logger,
+                values: profile.values ? clone(profile.values) : {},
+                dataDirectory: ctx.options?.dataDirectory,
+            });
+        }
+        else {
+            /* Update values */
+            if (!ctx.stackExecutor.execute('values', () => {
+                _patchValues(ctx, ctx.processor, ctx.processor.values, '', profile.values, r1.metadata.variables || {}, oldProfile?.values, oldMetadata.variables);
+            })) {
+                return false;
+            }
+        }
         const cmpCtx = {
             ...ctx,
-            owner: processor,
+            owner: ctx.processor,
             curPath: '',
-            newMetadataComponents: newMetadata.components,
+            newMetadataComponents: r1.metadata.components,
             newProfileComponents: profile.components,
-            oldMetadataComponents: processor[ProcessorFactory.METADATA_KEY]?.components,
-            oldProfileComponents: processor[ProcessorFactory.PROFILE_KEY]?.components,
+            oldMetadataComponents: oldMetadata?.components,
+            oldProfileComponents: oldProfile?.components,
         };
-        _validateComponents(cmpCtx);
-        await _configureComponents(cmpCtx);
-        processor[ProcessorFactory.METADATA_KEY] = newMetadata;
-        processor[ProcessorFactory.PROFILE_KEY] = profile;
+        if (!(_validateComponents(cmpCtx) && (await _configureComponents(cmpCtx)))) {
+            return false;
+        }
+        ctx.processor[ProcessorFactory.METADATA_KEY] = r1.metadata;
+        ctx.processor[ProcessorFactory.PROFILE_KEY] = profile;
+        return true;
     }
     function _validateComponents(ctx) {
-        const { newMetadataComponents, newProfileComponents, oldMetadataComponents, oldProfileComponents, curPath, owner, stackExecutor, processor, } = ctx;
+        const { newMetadataComponents, newProfileComponents, oldMetadataComponents, oldProfileComponents, curPath, owner, stackExecutor, } = ctx;
         if (!newMetadataComponents)
-            return;
-        // Stack: components
-        stackExecutor.execute('components', () => {
+            return true;
+        return stackExecutor.execute('components', () => {
             for (const [key, newChildMetadata] of Object.entries(newMetadataComponents)) {
                 // Stack: components/componentName
                 stackExecutor.execute(key, () => {
@@ -111,10 +181,9 @@ export var ProcessorFactory;
                     const newChildProfile = newProfileComponents[key];
                     const componentPath = curPath ? curPath + '/' + key : key;
                     const componentInstance = owner.components?.[key];
-                    if (processor.stopped &&
-                        oldChildProfile?.uri &&
+                    if (oldChildProfile?.uri &&
                         oldChildProfile?.uri !== newChildProfile.uri)
-                        throw new SbError('Cannot change component class while processor running. You should stop it first.');
+                        throw new SbError(`You should not change uri of the component (${componentPath})`);
                     /** Validate sub-components */
                     if (newChildMetadata.components && componentInstance) {
                         _validateComponents({
@@ -134,10 +203,10 @@ export var ProcessorFactory;
     async function _configureComponents(ctx) {
         const { newMetadataComponents, newProfileComponents, oldMetadataComponents, oldProfileComponents, curPath, owner, stackExecutor, processor, } = ctx;
         if (!newMetadataComponents)
-            return;
+            return true;
         owner.components = owner.components || {};
         // Stack: components
-        await stackExecutor.executeAsync('components', async () => {
+        return await stackExecutor.executeAsync('components', async () => {
             for (const [key, newChildMetadata] of Object.entries(newMetadataComponents)) {
                 // Stack: components/componentName
                 await stackExecutor.executeAsync(key, async () => {
@@ -150,17 +219,18 @@ export var ProcessorFactory;
                         const newChildProfile = newProfileComponents[key];
                         const componentPath = curPath ? curPath + '/' + key : key;
                         let componentInstance = owner.components[key];
-                        /** Create the component only if the owner stopped */ // todo implement hotplug components
-                        if (owner.stopped) {
+                        /** Create the component */
+                        if (!componentInstance) {
                             const compReg = ExtensionRegistry.getComponent(newChildMetadata.classUri);
                             /** Create the component instance */
                             const compClass = await compReg.getClass();
+                            const values = { ...newChildProfile.values };
                             componentInstance = new compClass({
                                 processor: processor,
                                 parent: owner,
                                 name: key,
                                 path: componentPath,
-                                values: newChildProfile.values || {},
+                                values,
                             });
                             owner.components[key] = componentInstance;
                             if (newChildMetadata.propertyKey)
@@ -168,30 +238,7 @@ export var ProcessorFactory;
                         }
                         else {
                             componentInstance.values = {};
-                            const patchValues = (target, valPath, newValues, newVariables, oldValues, oldVariables) => {
-                                if (oldValues)
-                                    Object.assign(target, oldValues);
-                                const updatedValues = ctx.valueUpdates.get(componentInstance) || [];
-                                ctx.valueUpdates.set(componentInstance, updatedValues);
-                                if (newVariables) {
-                                    for (const [varKey, varMeta] of Object.entries(newVariables)) {
-                                        const keyPath = valPath ? valPath + '.' + varKey : varKey;
-                                        /** Update only hotplug variables */
-                                        if (varMeta?.hotPlug !== true)
-                                            continue;
-                                        if (varMeta.type === 'nested') {
-                                            target[varKey] = {};
-                                            patchValues(target[varKey], keyPath, newValues[varKey], newVariables[varKey]?.variables || {}, oldValues?.[varKey], oldVariables?.[varKey]?.variables);
-                                            continue;
-                                        }
-                                        if (!equal(target[varKey], newValues[varKey])) {
-                                            updatedValues.push(keyPath);
-                                            target[varKey] = newValues[varKey];
-                                        }
-                                    }
-                                }
-                            };
-                            patchValues(componentInstance.values, '', newChildProfile.values || {}, newChildMetadata.variables || {}, oldChildProfile?.values, oldChildMetadata?.variables);
+                            _patchValues(ctx, componentInstance, componentInstance.values, '', newChildProfile.values || {}, newChildMetadata.variables || {}, oldChildProfile?.values, oldChildMetadata?.variables);
                         }
                         /** Create the child logger */
                         componentInstance.logger = owner.logger?.child({
@@ -201,7 +248,7 @@ export var ProcessorFactory;
                             componentInstance.logger.level =
                                 newChildProfile.settings?.logs?.level;
                         }
-                        /** Initialize sub components */
+                        /** Initialize sub-components */
                         if (newChildMetadata.components) {
                             await _configureComponents({
                                 ...ctx,
@@ -218,4 +265,27 @@ export var ProcessorFactory;
             }
         });
     }
+    function _patchValues(ctx, instance, target, valPath, newValues, newVariables, oldValues, oldVariables) {
+        if (oldValues)
+            Object.assign(target, oldValues);
+        const updatedValues = ctx.valueUpdates?.get(instance) || [];
+        ctx.valueUpdates?.set(instance, updatedValues);
+        if (newVariables) {
+            for (const [varKey, varMeta] of Object.entries(newVariables)) {
+                const keyPath = valPath ? valPath + '.' + varKey : varKey;
+                /** Update only hotplug variables */
+                if (varMeta?.hotPlug !== true)
+                    continue;
+                if (varMeta.type === 'nested') {
+                    target[varKey] = {};
+                    _patchValues(ctx, instance, target[varKey], keyPath, newValues[varKey], newVariables[varKey]?.variables || {}, oldValues?.[varKey], oldVariables?.[varKey]?.variables);
+                    continue;
+                }
+                if (!equal(target[varKey], newValues[varKey])) {
+                    updatedValues.push(keyPath);
+                    target[varKey] = newValues[varKey];
+                }
+            }
+        }
+    }
 })(ProcessorFactory || (ProcessorFactory = {}));

package/registry/extension-package.d.ts

@@ -1,5 +1,5 @@
 import 'reflect-metadata';
-import { Type } from 'ts-gems';
+import type { Type } from 'ts-gems';
 import { BaseElement } from '../classes/base-element.js';
 import { ComponentBase } from '../classes/component-base.js';
 import { ProcessorBase } from '../classes/processor-base.js';

package/registry/extension-package.js

@@ -1,6 +1,10 @@
 import 'reflect-metadata';
+import { BaseElement } from '../classes/base-element.js';
+import { ComponentBase } from '../classes/component-base.js';
+import { ProcessorBase } from '../classes/processor-base.js';
 import { SbError } from '../classes/sb-error.js';
-import { isComponentBase, isProcessorBase } from '../utils/type-guartds.js';
+import { ComponentMetadata, ElementMetadata, ProcessorMetadata, } from '../models/index.js';
+import { isComponentBase, isProcessorBase } from '../utils/type-guards.js';
 /**
  *
  */

package/registry/extension-registry.d.ts

@@ -1,6 +1,6 @@
 import { ResponsiveMap } from '@opra/common';
 import { AsyncEventEmitter } from 'node-events-async';
-import { Type } from 'ts-gems';
+import type { Type } from 'ts-gems';
 import { ComponentBase } from '../classes/component-base.js';
 import { ProcessorBase } from '../classes/processor-base.js';
 import { ComponentExtension, ExtensionPackage, ProcessorExtension } from './extension-package.js';

package/registry/extension-registry.js

@@ -5,6 +5,8 @@ import { updateErrorMessage } from '@jsopen/objects';
 import { ResponsiveMap } from '@opra/common';
 import { AsyncEventEmitter } from 'node-events-async';
 import semver from 'semver';
+import { ComponentBase } from '../classes/component-base.js';
+import { ProcessorBase } from '../classes/processor-base.js';
 import { SbError } from '../classes/sb-error.js';
 import { CLASS_METADATA, CLASS_TYPE } from '../constants.js';
 import { locatePackageJson } from '../utils/locate-package-json.js';

package/utils/decode-profile.js

@@ -1,7 +1,7 @@
-import { isAny, isBase64, isBoolean, isDateString, isEmail, isHex, isNumber, isString, isTime, isURL, validator, vg, } from 'valgen';
+import { isAny, isBase64, isBigint, isBoolean, isDateString, isEmail, isHex, isNumber, isString, isTime, isURL, validator, vg, } from 'valgen';
 import { SbValidationError } from '../classes/sb-error.js';
 import { StackExecutor } from '../classes/stack-executor.js';
-import { Profile, VariableType, } from '../models/index.js';
+import { ElementComponentMetadata, ProcessorMetadata, Profile, ProfileComponent, VariableMetadataRecord, VariableType, } from '../models/index.js';
 import { getModelsDocument } from '../models-document.js';
 import { secretDecryptor, secretEncryptor } from './encrypt-helpers.js';
 /**
@@ -179,6 +179,10 @@ function _decodeVariables(stackExecutor, codec, metadata, profile, options) {
                         fns.push(isNumber);
                         break;
                     }
+                    case VariableType.BigInt: {
+                        fns.push(isBigint);
+                        break;
+                    }
                     case VariableType.Boolean: {
                         fns.push(isBoolean);
                         break;

package/utils/materialize-metadata.d.ts

@@ -8,6 +8,10 @@ export declare function materializeMetadata(profile: Profile, returnUndefinedCom
  *
  */
 export declare function materializeMetadataSilent(profile: Profile, returnUndefinedComponentsAsAbstract?: boolean): {
+    result: true;
     metadata: ProcessorMetadata;
-    issues?: StackExecutor.Issue[];
+    issues: StackExecutor.Issue[];
+} | {
+    result: false;
+    issues: StackExecutor.Issue[];
 };

package/utils/materialize-metadata.js

@@ -1,28 +1,28 @@
 import { clone, merge, omit, omitUndefined } from '@jsopen/objects';
 import { SbValidationError } from '../classes/sb-error.js';
 import { StackExecutor } from '../classes/stack-executor.js';
-import { VariableType, } from '../models/index.js';
+import { ElementComponentMetadata, ElementComponentMetadataRecord, ProcessorMetadata, Profile, ProfileComponent, VariableMetadata, VariableMetadataRecord, VariableType, } from '../models/index.js';
 import { ExtensionRegistry } from '../registry/extension-registry.js';
 /**
  * Materializes metadata from profile.
  */
 export function materializeMetadata(profile, returnUndefinedComponentsAsAbstract) {
-    const { metadata, issues } = materializeMetadataSilent(profile, returnUndefinedComponentsAsAbstract);
-    if (issues?.length) {
+    const r = materializeMetadataSilent(profile, returnUndefinedComponentsAsAbstract);
+    if (!r.result) {
         const msg = 'Worker profile validation error.\n  ' +
-            issues
+            r.issues
                 .map(issue => `- ${issue.message}. Location: /${issue.location}`)
                 .join('\n  ');
-        issues.forEach(issue => {
+        r.issues.forEach(issue => {
             if (issue instanceof SbValidationError)
                 delete issue.stack;
         });
         throw new SbValidationError(msg, {
             workerId: profile.id,
-            issues,
+            issues: r.issues,
         });
     }
-    return metadata;
+    return r.metadata;
 }
 /**
  *
@@ -48,8 +48,8 @@ export function materializeMetadataSilent(profile, returnUndefinedComponentsAsAb
         });
     }
     if (stackExecutor.issues?.length)
-        return { metadata, issues: stackExecutor.issues };
-    return { metadata };
+        return { result: false, issues: stackExecutor.issues };
+    return { result: true, metadata, issues: stackExecutor.issues };
 }
 /**
  *

package/utils/normalize-metadata.js

@@ -1,6 +1,7 @@
 import { deepClone, merge } from '@jsopen/objects';
 import { SbValidationError } from '../classes/sb-error.js';
-import { ComponentMetadata, ProcessorMetadata, } from '../models/index.js';
+import { StackExecutor } from '../classes/stack-executor.js';
+import { ComponentMetadata, ElementComponentMetadataRecord, ProcessorMetadata, VariableMetadataRecord, } from '../models/index.js';
 import { initializeModelsDocument } from '../models-document.js';
 import { resolvePromisesDeep } from './resolve-promises.js';
 export async function normalizeProcessorMetadata(metadata) {
@@ -38,7 +39,8 @@ export async function normalizeProcessorMetadataSilent(metadata) {
     cloned.variables = normalizeVariables(cloned.variables);
     cloned.components = normalizeComponents(cloned.components);
     const { value, errors } = decoder.silent(cloned);
-    merge(value, metadata, { keepExisting: true, deep: 'full' });
+    if (value)
+        merge(value, metadata, { keepExisting: true, deep: 'full' });
     return {
         metadata: value || cloned,
         issues: errors?.map(x => ({
@@ -83,7 +85,8 @@ export async function normalizeComponentMetadataSilent(metadata) {
     cloned.variables = normalizeVariables(cloned.variables);
     cloned.components = normalizeComponents(cloned.components);
     const { value, errors } = decoder.silent(cloned);
-    merge(value, metadata, { keepExisting: true, deep: 'full' });
+    if (value)
+        merge(value, metadata, { keepExisting: true, deep: 'full' });
     return {
         metadata: value || cloned,
         issues: errors?.map(x => ({