@acorex-platform/module-platform-management-client 0.0.21

package/fesm2022/acorex-platform-module-platform-management-client-acorex-platform-module-platform-management-client-V_ao4WVM.mjs

@@ -0,0 +1,4599 @@
+import { AXPSessionService, AXP_PERMISSION_DEFINITION_PROVIDER } from '@acorex-platform/framework-client/auth';
+import { AXPSettingsService, AXPMenuProviderService, AXPTokenDefinitionService, AXP_TOKEN_DEFINITION_PROVIDER, AXP_PROTECTED_ROUTE_GUARDS, AXP_MENU_MIDDLEWARE, AXP_MENU_PROVIDER } from '@acorex-platform/framework-client/common';
+import { AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER, AXP_MODULE_MANIFEST_PROVIDER, AXP_FEATURE_DEFINITION_PROVIDER } from '@acorex-platform/framework-client/core';
+import { AXPRootLayoutComponent } from '@acorex-platform/framework-client/themes/default';
+import { AXP_WIDGETS_EDITOR_CATEGORY, AXPWidgetCoreModule, AXP_WIDGET_DEFINITION_PROVIDER } from '@acorex-platform/framework-client/layout/widget-core';
+import { provideCommandSetups, AXPCommandExecutor, provideQuerySetups } from '@acorex-platform/framework-client/runtime';
+import * as i0 from '@angular/core';
+import { Injectable, inject, NgModule, Injector, input, output, viewChild, signal, DestroyRef, computed, afterNextRender, effect, ViewEncapsulation, ChangeDetectionStrategy, Component, Directive } from '@angular/core';
+import { ROUTES } from '@angular/router';
+import { AXPWidgetGroupEnum } from '@acorex-platform/framework-shared/widget-core';
+import { AXP_NAME_PROPERTY, AXP_DATA_PATH_PROPERTY, AXP_READONLY_PROPERTY, AXP_DISABLED_PROPERTY } from '@acorex-platform/framework-client/layout/widgets';
+import { AXPPlatformManagementFeatureKeys, RootConfig, AXM_TOKEN_RESOLVE_COMMAND_KEY, AXPApplicationsPlatformPermissionKeys, AXPPlatformManagementMenuKeys } from '@acorex-platform/module-platform-management-client/contracts';
+import { AXPPlatformScope, runtimeCommandPayloadData } from '@acorex-platform/framework-shared/core';
+import { AXPMenuCustomizerService, AXP_MENU_CUSTOMIZER_SERVICE } from '@acorex-platform/framework-client/layout/components';
+import { cloneDeep } from 'lodash';
+import { AXPEntityService } from '@acorex-platform/framework-client/layout/entity';
+import { AXDialogService } from '@acorex/components/dialog';
+import { AXTranslationService } from '@acorex/core/translation';
+import { SwUpdate } from '@angular/service-worker';
+import { AXPCommonMenuKeys, AXPCommonPermissionGroupKeys } from '@acorex-platform/module-common-client/contracts';
+import { AXP_ENTITY_DEFINITION_CRUD_SERVICE } from '@acorex-platform/framework-client/domain';
+import { AXPanViewDirective } from '@acorex/cdk/pan-view';
+import * as i1$1 from '@acorex/components/button';
+import { AXButtonModule } from '@acorex/components/button';
+import * as i2 from '@acorex/components/decorators';
+import { AXDecoratorModule } from '@acorex/components/decorators';
+import * as i1 from '@angular/common';
+import { CommonModule } from '@angular/common';
+
+const REST_API_GENERATOR_WIDGET_NAME = 'rest-api-generator-editor';
+const REST_API_GENERATOR_IMPORT_DEBOUNCE_MS = 500;
+
+//#region ----- Imports -----
+//#endregion
+//#region ----- Config -----
+const AXMRestApiGeneratorWidget = {
+    name: REST_API_GENERATOR_WIDGET_NAME,
+    title: '@platform-management:query-definitions.wizard.create.rest-api-generator.title',
+    description: '@platform-management:query-definitions.wizard.create.rest-api-generator.description',
+    icon: 'fa-light fa-cloud-arrow-up',
+    categories: AXP_WIDGETS_EDITOR_CATEGORY,
+    groups: [AXPWidgetGroupEnum.UtilityWidget],
+    type: 'editor',
+    defaultFilterWidgetName: 'string-filter',
+    options: {
+        needLabel: false,
+    },
+    properties: [AXP_NAME_PROPERTY, AXP_DATA_PATH_PROPERTY, AXP_READONLY_PROPERTY, AXP_DISABLED_PROPERTY],
+    components: {
+        edit: {
+            component: () => import('./acorex-platform-module-platform-management-client-rest-api-generator-widget-edit.component-BBwrzcXa.mjs').then((c) => c.AXMRestApiGeneratorWidgetEditComponent),
+        },
+        designer: {
+            component: () => import('./acorex-platform-module-platform-management-client-rest-api-generator-widget-edit.component-BBwrzcXa.mjs').then((c) => c.AXMRestApiGeneratorWidgetEditComponent),
+        },
+        view: {
+            component: () => import('./acorex-platform-module-platform-management-client-rest-api-generator-widget-view.component-DBlZVz6u.mjs').then((c) => c.AXMRestApiGeneratorWidgetViewComponent),
+        },
+        column: {
+            component: () => import('./acorex-platform-module-platform-management-client-rest-api-generator-widget-column.component-CYb2zOSj.mjs').then((c) => c.AXMRestApiGeneratorWidgetColumnComponent),
+        },
+    },
+};
+//#endregion
+
+//#region ----- Constants -----
+const HTTP_METHODS = ['GET', 'POST', 'DELETE', 'PUT', 'PATCH'];
+const VALUE_FLAGS = {
+    '-X': 'method',
+    '--request': 'method',
+    '-H': 'header',
+    '--header': 'header',
+    '-d': 'data',
+    '--data': 'data',
+    '--data-raw': 'data',
+    '--data-binary': 'data',
+    '--data-ascii': 'data',
+    '--data-urlencode': 'data',
+    '--json': 'json',
+    '-u': 'user',
+    '--user': 'user',
+    '--url': 'url',
+    '-A': 'user-agent',
+    '--user-agent': 'user-agent',
+    '-b': 'cookie',
+    '--cookie': 'cookie',
+    '-e': 'referer',
+    '--referer': 'referer',
+    '--oauth2-bearer': 'bearer',
+    '-F': 'form',
+    '--form': 'form',
+    '-o': 'ignore',
+    '--output': 'ignore',
+    '-w': 'ignore',
+    '--write-out': 'ignore',
+    '-m': 'ignore',
+    '--max-time': 'ignore',
+    '--connect-timeout': 'ignore',
+    '--retry': 'ignore',
+};
+const SKIP_FLAGS = new Set([
+    '-v',
+    '--verbose',
+    '-k',
+    '--insecure',
+    '--compressed',
+    '-s',
+    '--silent',
+    '-S',
+    '--show-error',
+    '-L',
+    '--location',
+    '-i',
+    '--include',
+    '-I',
+    '--head',
+    '-#',
+    '--progress-bar',
+    '--http1.0',
+    '--http1.1',
+    '--http2',
+    '--globoff',
+    '-g',
+    '--fail',
+    '-f',
+    '--remote-name',
+    '-O',
+    '--location-trusted',
+    '--no-progress-meter',
+]);
+//#endregion
+//#region ----- Public API -----
+function createEmptyRestApiOutput() {
+    return {
+        url: '',
+        method: 'GET',
+        body: '',
+        headers: {
+            Authorization: '',
+            ContentType: '',
+        },
+        queries: [{}],
+    };
+}
+function normalizeRestApiOutput(value) {
+    const empty = createEmptyRestApiOutput();
+    if (value == null || typeof value !== 'object') {
+        return empty;
+    }
+    const headers = value.headers && typeof value.headers === 'object' ? value.headers : {};
+    const extraHeaders = {};
+    for (const [key, headerValue] of Object.entries(headers)) {
+        if (key === 'Authorization' || key === 'ContentType' || key === 'tempId') {
+            continue;
+        }
+        if (typeof headerValue === 'string' && headerValue.trim()) {
+            extraHeaders[key] = headerValue;
+        }
+    }
+    const authorization = headers['Authorization'];
+    const contentType = headers['ContentType'];
+    return {
+        url: typeof value.url === 'string' ? value.url.trim() : '',
+        method: normalizeMethod(value.method),
+        body: typeof value.body === 'string' ? value.body : value.body == null ? '' : String(value.body),
+        headers: {
+            Authorization: typeof authorization === 'string' ? authorization : '',
+            ContentType: typeof contentType === 'string' ? contentType : '',
+            ...extraHeaders,
+        },
+        queries: normalizeQueries(value.queries),
+    };
+}
+function formatRestApiSummary(value) {
+    const url = value?.url?.trim() ?? '';
+    if (!url) {
+        return '';
+    }
+    return `${value?.method ?? 'GET'} ${url}`;
+}
+function parseHttpRequest(input) {
+    const source = input.trim();
+    if (!source) {
+        return { ok: false };
+    }
+    if (looksLikeCurl(source)) {
+        return wrapParse('curl', parseCurl(source));
+    }
+    if (/\bfetch\s*\(/i.test(source)) {
+        return wrapParse('fetch', parseFetch(source));
+    }
+    if (/^(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\s+\S+/i.test(source)) {
+        return wrapParse('http', parseRawHttp(source));
+    }
+    if (source.startsWith('{')) {
+        return wrapParse('json', parseJsonRequest(source));
+    }
+    if (/^https?:\/\//i.test(source.split(/\s/, 1)[0] ?? '')) {
+        return wrapParse('url', parseUrlOnly(source));
+    }
+    return { ok: false };
+}
+//#endregion
+//#region ----- Format parsers -----
+function parseCurl(source) {
+    const tokens = tokenizeCommandLine(source);
+    if (tokens.length === 0) {
+        return null;
+    }
+    let index = 0;
+    if (tokens[index] === '$') {
+        index += 1;
+    }
+    if (/^curl(?:\.exe)?$/i.test(tokens[index] ?? '')) {
+        index += 1;
+    }
+    const output = createEmptyRestApiOutput();
+    let rawUrl = '';
+    let body = '';
+    let hasJsonFlag = false;
+    let hasFormFlag = false;
+    while (index < tokens.length) {
+        const token = tokens[index] ?? '';
+        if (token === '--') {
+            const rest = tokens[index + 1];
+            if (rest && !rawUrl) {
+                rawUrl = rest;
+            }
+            break;
+        }
+        if (!token.startsWith('-')) {
+            if (!rawUrl) {
+                rawUrl = token;
+            }
+            index += 1;
+            continue;
+        }
+        const { name, inlineValue, kind } = resolveFlag(token);
+        if (kind === 'skip') {
+            index += 1;
+            continue;
+        }
+        let flagValue = inlineValue;
+        if (flagValue == null && kind !== 'skip') {
+            const next = tokens[index + 1];
+            if (next != null && !next.startsWith('-')) {
+                flagValue = next;
+                index += 2;
+            }
+            else {
+                index += 1;
+                continue;
+            }
+        }
+        else {
+            index += 1;
+        }
+        if (kind === 'ignore' || flagValue == null) {
+            continue;
+        }
+        switch (name) {
+            case 'method':
+                output.method = normalizeMethod(flagValue);
+                break;
+            case 'header':
+                applyHeader(output, flagValue);
+                break;
+            case 'data':
+                body = appendBody(body, flagValue);
+                break;
+            case 'json':
+                body = appendBody(body, flagValue);
+                hasJsonFlag = true;
+                break;
+            case 'form':
+                body = appendBody(body, flagValue);
+                hasFormFlag = true;
+                break;
+            case 'user':
+                applyUser(output, flagValue);
+                break;
+            case 'url':
+                rawUrl = flagValue;
+                break;
+            case 'user-agent':
+                applyHeader(output, `User-Agent: ${flagValue}`);
+                break;
+            case 'cookie':
+                applyHeader(output, `Cookie: ${flagValue}`);
+                break;
+            case 'referer':
+                applyHeader(output, `Referer: ${flagValue}`);
+                break;
+            case 'bearer':
+                output.headers.Authorization = `Bearer ${flagValue}`;
+                break;
+            default:
+                break;
+        }
+    }
+    if (rawUrl.trim()) {
+        const split = splitUrlAndQuery(rawUrl);
+        output.url = split.url;
+        output.queries = split.queries;
+    }
+    output.body = body;
+    if (hasJsonFlag) {
+        output.headers.ContentType = output.headers.ContentType || 'application/json';
+    }
+    else if (hasFormFlag) {
+        output.headers.ContentType = output.headers.ContentType || 'multipart/form-data';
+    }
+    else if (body && !output.headers.ContentType) {
+        output.headers.ContentType = looksLikeJson(body) ? 'application/json' : 'application/x-www-form-urlencoded';
+    }
+    if (body && output.method === 'GET') {
+        output.method = 'POST';
+    }
+    const normalized = normalizeRestApiOutput(output);
+    return hasParsedContent(normalized) ? normalized : null;
+}
+function parseFetch(source) {
+    const fetchIndex = source.search(/\bfetch\s*\(/i);
+    if (fetchIndex < 0) {
+        return null;
+    }
+    const openParen = source.indexOf('(', fetchIndex);
+    if (openParen < 0) {
+        return null;
+    }
+    const args = extractCallArguments(source, openParen);
+    if (!args) {
+        return null;
+    }
+    const urlRaw = unquote(args[0]?.trim() ?? '');
+    if (!urlRaw) {
+        return null;
+    }
+    const output = createEmptyRestApiOutput();
+    const split = splitUrlAndQuery(urlRaw);
+    output.url = split.url;
+    output.queries = split.queries;
+    const optionsSrc = args[1]?.trim();
+    if (optionsSrc?.startsWith('{')) {
+        applyFetchOptions(output, optionsSrc);
+    }
+    return output.url ? normalizeRestApiOutput(output) : null;
+}
+function parseRawHttp(source) {
+    const normalized = source.replace(/\r\n/g, '\n');
+    const headerBodySplit = normalized.split(/\n\n/);
+    const headerBlock = headerBodySplit[0] ?? '';
+    const body = headerBodySplit.slice(1).join('\n\n');
+    const lines = headerBlock.split('\n').map((line) => line.trimEnd());
+    const requestLine = lines[0]?.trim() ?? '';
+    const requestMatch = requestLine.match(/^(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\s+(\S+)(?:\s+HTTP\/[\d.]+)?$/i);
+    if (!requestMatch) {
+        return null;
+    }
+    const output = createEmptyRestApiOutput();
+    output.method = normalizeMethod(requestMatch[1] ?? 'GET');
+    let path = requestMatch[2] ?? '';
+    let host = '';
+    for (let i = 1; i < lines.length; i += 1) {
+        const line = lines[i]?.trim() ?? '';
+        if (!line) {
+            continue;
+        }
+        applyHeader(output, line);
+        const headerMatch = line.match(/^([^:]+):\s*(.*)$/);
+        if (headerMatch && headerMatch[1]?.toLowerCase() === 'host') {
+            host = headerMatch[2]?.trim() ?? '';
+        }
+    }
+    if (/^https?:\/\//i.test(path)) {
+        const split = splitUrlAndQuery(path);
+        output.url = split.url;
+        output.queries = split.queries;
+    }
+    else {
+        const origin = host ? `https://${host}` : '';
+        const combined = origin ? `${origin}${path.startsWith('/') ? path : `/${path}`}` : path;
+        const split = splitUrlAndQuery(combined);
+        output.url = split.url;
+        output.queries = split.queries;
+    }
+    output.body = body.trim();
+    if (output.body && output.method === 'GET') {
+        output.method = 'POST';
+    }
+    return output.url ? normalizeRestApiOutput(output) : null;
+}
+function parseJsonRequest(source) {
+    let parsed;
+    try {
+        parsed = JSON.parse(source);
+    }
+    catch {
+        return null;
+    }
+    if (parsed == null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        return null;
+    }
+    const record = parsed;
+    const url = pickString(record, ['url', 'raw_url', 'rawUrl']);
+    if (!url) {
+        return null;
+    }
+    const output = createEmptyRestApiOutput();
+    const split = splitUrlAndQuery(url);
+    output.url = split.url;
+    output.queries = split.queries;
+    output.method = normalizeMethod(pickString(record, ['method']) ?? 'GET');
+    const body = record['body'] ?? record['data'];
+    if (typeof body === 'string') {
+        output.body = body;
+    }
+    else if (body != null && typeof body === 'object') {
+        output.body = JSON.stringify(body);
+        output.headers.ContentType = output.headers.ContentType || 'application/json';
+    }
+    const headers = record['headers'];
+    if (headers && typeof headers === 'object' && !Array.isArray(headers)) {
+        for (const [key, value] of Object.entries(headers)) {
+            if (typeof value === 'string') {
+                applyHeader(output, `${key}: ${value}`);
+            }
+        }
+    }
+    const queries = record['queries'] ?? record['query'];
+    const fromQueries = queriesFromUnknown(queries);
+    if (fromQueries.length > 0 && hasNamedQuery(fromQueries)) {
+        output.queries = fromQueries;
+    }
+    return normalizeRestApiOutput(output);
+}
+function parseUrlOnly(source) {
+    const firstLine = source.split(/\s/, 1)[0]?.trim() ?? '';
+    if (!/^https?:\/\//i.test(firstLine)) {
+        return null;
+    }
+    const output = createEmptyRestApiOutput();
+    const split = splitUrlAndQuery(firstLine);
+    output.url = split.url;
+    output.queries = split.queries;
+    return output.url ? normalizeRestApiOutput(output) : null;
+}
+//#endregion
+//#region ----- Curl helpers -----
+function looksLikeCurl(source) {
+    const trimmed = source.trim().replace(/^\$\s+/, '');
+    if (!trimmed || trimmed.startsWith('{')) {
+        return false;
+    }
+    if (/^(?:curl(?:\.exe)?)\b/i.test(trimmed)) {
+        return true;
+    }
+    if (/\bcurl(?:\.exe)?\b/i.test(trimmed) && hasCurlFlags(trimmed)) {
+        return true;
+    }
+    return hasCurlFlags(trimmed);
+}
+function hasCurlFlags(source) {
+    return /(?:^|[\s\\])(?:-H|--header|-X|--request|-d|--data(?:-raw|-binary|-ascii|-urlencode)?|--json|--url|-F|--form|-A|--user-agent|-u|--user|-b|--cookie|-e|--referer|--oauth2-bearer)\b/.test(source);
+}
+function tokenizeCommandLine(input) {
+    const normalized = input
+        .replace(/\\\r?\n/g, ' ')
+        .replace(/\^\r?\n/g, ' ')
+        .replace(/`\r?\n/g, ' ')
+        .trim();
+    const tokens = [];
+    let i = 0;
+    while (i < normalized.length) {
+        while (i < normalized.length && /\s/.test(normalized[i] ?? '')) {
+            i += 1;
+        }
+        if (i >= normalized.length) {
+            break;
+        }
+        if (normalized[i] === '$' && (normalized[i + 1] === "'" || normalized[i + 1] === '"')) {
+            const quote = normalized[i + 1] ?? "'";
+            const quoted = readQuoted(normalized, i + 2, quote, true);
+            tokens.push(quoted.value);
+            i = quoted.nextIndex;
+            continue;
+        }
+        const quote = normalized[i];
+        if (quote === "'" || quote === '"' || quote === '`') {
+            const quoted = readQuoted(normalized, i + 1, quote, false);
+            tokens.push(quoted.value);
+            i = quoted.nextIndex;
+            continue;
+        }
+        let value = '';
+        while (i < normalized.length && !/\s/.test(normalized[i] ?? '')) {
+            const current = normalized[i] ?? '';
+            const next = normalized[i + 1] ?? '';
+            if (current === '$' && (next === "'" || next === '"') && value.length > 0) {
+                break;
+            }
+            if ((current === "'" || current === '"' || current === '`') && value.length > 0) {
+                break;
+            }
+            value += current;
+            i += 1;
+        }
+        tokens.push(value);
+    }
+    return tokens;
+}
+function readQuoted(source, start, quote, ansiC) {
+    let value = '';
+    let i = start;
+    while (i < source.length) {
+        const current = source[i] ?? '';
+        if (ansiC && current === '\\' && i + 1 < source.length) {
+            const decoded = decodeAnsiCEscape(source, i);
+            value += decoded.value;
+            i = decoded.nextIndex;
+            continue;
+        }
+        if (!ansiC && current === '\\' && quote !== "'" && i + 1 < source.length) {
+            value += source[i + 1] ?? '';
+            i += 2;
+            continue;
+        }
+        if (current === quote) {
+            i += 1;
+            break;
+        }
+        value += current;
+        i += 1;
+    }
+    return { value, nextIndex: i };
+}
+function decodeAnsiCEscape(source, index) {
+    const next = source[index + 1] ?? '';
+    switch (next) {
+        case 'n':
+            return { value: '\n', nextIndex: index + 2 };
+        case 'r':
+            return { value: '\r', nextIndex: index + 2 };
+        case 't':
+            return { value: '\t', nextIndex: index + 2 };
+        case 'v':
+            return { value: '\v', nextIndex: index + 2 };
+        case 'b':
+            return { value: '\b', nextIndex: index + 2 };
+        case 'f':
+            return { value: '\f', nextIndex: index + 2 };
+        case 'a':
+            return { value: '\u0007', nextIndex: index + 2 };
+        case '\\':
+        case "'":
+        case '"':
+        case '?':
+            return { value: next, nextIndex: index + 2 };
+        case 'x': {
+            const hex = source.slice(index + 2, index + 4);
+            if (/^[0-9a-fA-F]{2}$/.test(hex)) {
+                return { value: String.fromCharCode(Number.parseInt(hex, 16)), nextIndex: index + 4 };
+            }
+            return { value: next, nextIndex: index + 2 };
+        }
+        default:
+            return { value: next, nextIndex: index + 2 };
+    }
+}
+function resolveFlag(token) {
+    const eq = token.indexOf('=');
+    let flag = token;
+    let inlineValue;
+    if (eq > 1) {
+        flag = token.slice(0, eq);
+        inlineValue = token.slice(eq + 1);
+    }
+    if (SKIP_FLAGS.has(flag) || SKIP_FLAGS.has(token)) {
+        return { name: flag, kind: 'skip' };
+    }
+    const mapped = VALUE_FLAGS[flag];
+    if (mapped) {
+        return { name: mapped, inlineValue, kind: mapped };
+    }
+    if (flag.startsWith('-X') && flag.length > 2 && !flag.startsWith('--')) {
+        return { name: 'method', inlineValue: flag.slice(2), kind: 'method' };
+    }
+    if (flag.startsWith('-H') && flag.length > 2 && !flag.startsWith('--')) {
+        return { name: 'header', inlineValue: flag.slice(2), kind: 'header' };
+    }
+    if (/^-[a-zA-Z]{2,}$/.test(flag) && !flag.startsWith('--')) {
+        return { name: flag, kind: 'skip' };
+    }
+    return { name: flag, inlineValue, kind: 'skip' };
+}
+function appendBody(current, next) {
+    if (!current) {
+        return next;
+    }
+    return `${current}&${next}`;
+}
+function applyUser(output, value) {
+    const colon = value.indexOf(':');
+    const user = colon >= 0 ? value.slice(0, colon) : value;
+    const password = colon >= 0 ? value.slice(colon + 1) : '';
+    output.headers.Authorization = `Basic ${encodeBase64(`${user}:${password}`)}`;
+}
+//#endregion
+//#region ----- Fetch helpers -----
+function extractCallArguments(source, openParen) {
+    let depthParen = 0;
+    let depthBrace = 0;
+    let depthBracket = 0;
+    let quote = null;
+    let escaped = false;
+    const args = [];
+    let current = '';
+    for (let i = openParen; i < source.length; i += 1) {
+        const ch = source[i] ?? '';
+        if (quote) {
+            current += ch;
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (ch === '\\') {
+                escaped = true;
+                continue;
+            }
+            if (ch === quote) {
+                quote = null;
+            }
+            continue;
+        }
+        if (ch === '"' || ch === "'" || ch === '`') {
+            quote = ch;
+            if (depthParen > 0) {
+                current += ch;
+            }
+            continue;
+        }
+        if (ch === '(') {
+            depthParen += 1;
+            if (depthParen > 1) {
+                current += ch;
+            }
+            continue;
+        }
+        if (ch === ')') {
+            depthParen -= 1;
+            if (depthParen === 0) {
+                const trimmed = current.trim();
+                if (trimmed) {
+                    args.push(trimmed);
+                }
+                return args;
+            }
+            current += ch;
+            continue;
+        }
+        if (ch === '{') {
+            depthBrace += 1;
+            current += ch;
+            continue;
+        }
+        if (ch === '}') {
+            depthBrace -= 1;
+            current += ch;
+            continue;
+        }
+        if (ch === '[') {
+            depthBracket += 1;
+            current += ch;
+            continue;
+        }
+        if (ch === ']') {
+            depthBracket -= 1;
+            current += ch;
+            continue;
+        }
+        if (ch === ',' && depthParen === 1 && depthBrace === 0 && depthBracket === 0) {
+            args.push(current.trim());
+            current = '';
+            continue;
+        }
+        current += ch;
+    }
+    return null;
+}
+function applyFetchOptions(output, optionsSrc) {
+    const methodMatch = optionsSrc.match(/method\s*:\s*(['"`])([^'"`]+)\1/i);
+    if (methodMatch?.[2]) {
+        output.method = normalizeMethod(methodMatch[2]);
+    }
+    const headersObject = extractNamedObject(optionsSrc, 'headers');
+    if (headersObject) {
+        applyObjectLiteralHeaders(output, headersObject);
+    }
+    const stringifyMatch = optionsSrc.match(/body\s*:\s*JSON\.stringify\s*\(([\s\S]+)\)\s*,?/i);
+    if (stringifyMatch?.[1]) {
+        const raw = stringifyMatch[1].trim().replace(/,\s*$/, '');
+        output.body = jsObjectToJson(raw) ?? raw;
+        output.headers.ContentType = output.headers.ContentType || 'application/json';
+        if (output.method === 'GET') {
+            output.method = 'POST';
+        }
+        return;
+    }
+    const bodyMatch = optionsSrc.match(/body\s*:\s*(['"`])([\s\S]*?)\1/);
+    if (bodyMatch?.[2] != null) {
+        output.body = bodyMatch[2];
+        if (output.body && !output.headers.ContentType) {
+            output.headers.ContentType = looksLikeJson(output.body) ? 'application/json' : output.headers.ContentType;
+        }
+        if (output.body && output.method === 'GET') {
+            output.method = 'POST';
+        }
+    }
+}
+function extractNamedObject(source, name) {
+    const match = source.match(new RegExp(`${name}\\s*:\\s*\\{`, 'i'));
+    if (!match || match.index == null) {
+        return null;
+    }
+    const brace = source.indexOf('{', match.index);
+    return extractBalanced(source, brace, '{', '}');
+}
+function applyObjectLiteralHeaders(output, objectSrc) {
+    const inner = objectSrc.replace(/^\{/, '').replace(/\}$/, '');
+    const pair = /(['"`]?)([A-Za-z0-9\-]+)\1\s*:\s*(['"`])([\s\S]*?)\3/g;
+    let match;
+    while ((match = pair.exec(inner)) != null) {
+        const key = match[2] ?? '';
+        const value = match[4] ?? '';
+        if (key) {
+            applyHeader(output, `${key}: ${value}`);
+        }
+    }
+}
+function jsObjectToJson(source) {
+    const trimmed = source.trim();
+    if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+        try {
+            return JSON.stringify(JSON.parse(trimmed));
+        }
+        catch {
+            return trimmed;
+        }
+    }
+    return null;
+}
+//#endregion
+//#region ----- Shared helpers -----
+function wrapParse(format, value) {
+    if (!hasParsedContent(value)) {
+        return { ok: false };
+    }
+    return { ok: true, format, value };
+}
+function hasParsedContent(value) {
+    if (!value) {
+        return false;
+    }
+    if (value.url.trim()) {
+        return true;
+    }
+    if (value.body.trim()) {
+        return true;
+    }
+    if (value.method !== 'GET') {
+        return true;
+    }
+    if (value.headers.Authorization.trim() || value.headers.ContentType.trim()) {
+        return true;
+    }
+    for (const [key, headerValue] of Object.entries(value.headers)) {
+        if (key === 'Authorization' || key === 'ContentType' || key === 'tempId') {
+            continue;
+        }
+        if (typeof headerValue === 'string' && headerValue.trim()) {
+            return true;
+        }
+    }
+    return (value.queries ?? []).some((query) => Object.entries(query).some(([key, queryValue]) => key !== 'tempId' && String(queryValue ?? '').trim()));
+}
+function normalizeMethod(value) {
+    const method = typeof value === 'string' ? value.trim().toUpperCase() : '';
+    if (method === 'HEAD') {
+        return 'GET';
+    }
+    if (HTTP_METHODS.includes(method)) {
+        return method;
+    }
+    return 'GET';
+}
+function normalizeQueries(value) {
+    const items = queriesFromUnknown(value);
+    return items.length > 0 ? items : [{}];
+}
+function queriesFromUnknown(value) {
+    if (Array.isArray(value)) {
+        return value
+            .map((item) => queryFromUnknown(item))
+            .filter((item) => item != null);
+    }
+    if (value && typeof value === 'object') {
+        return Object.entries(value)
+            .filter(([, queryValue]) => queryValue != null)
+            .map(([key, queryValue]) => ({
+            [key]: String(queryValue),
+            tempId: newTempId(),
+        }));
+    }
+    return [];
+}
+function queryFromUnknown(item) {
+    if (item == null || typeof item !== 'object') {
+        return null;
+    }
+    const record = item;
+    const named = Object.entries(record).filter(([key]) => key !== 'tempId');
+    if (named.length === 0) {
+        return { tempId: newTempId() };
+    }
+    const result = { tempId: newTempId() };
+    for (const [key, value] of named) {
+        result[key] = value == null ? '' : String(value);
+    }
+    return result;
+}
+function hasNamedQuery(queries) {
+    return queries.some((item) => Object.keys(item).some((key) => key !== 'tempId' && key.trim() !== ''));
+}
+function splitUrlAndQuery(raw) {
+    const trimmed = raw.trim();
+    try {
+        const absolute = /^https?:\/\//i.test(trimmed);
+        const parsed = absolute ? new URL(trimmed) : new URL(trimmed, 'https://placeholder.local');
+        const queries = queriesFromSearch(parsed.search);
+        parsed.search = '';
+        const url = absolute ? `${parsed.origin}${parsed.pathname}${parsed.hash}` : `${parsed.pathname}${parsed.hash}`;
+        return { url, queries };
+    }
+    catch {
+        return { url: trimmed, queries: [{}] };
+    }
+}
+function queriesFromSearch(search) {
+    const params = new URLSearchParams(search.startsWith('?') ? search.slice(1) : search);
+    const items = [];
+    params.forEach((value, key) => {
+        items.push({ [key]: value, tempId: newTempId() });
+    });
+    return items.length > 0 ? items : [{}];
+}
+function applyHeader(output, raw) {
+    const match = raw.match(/^([^:]+):\s*(.*)$/);
+    if (!match) {
+        return;
+    }
+    const name = (match[1] ?? '').trim();
+    const value = (match[2] ?? '').trim();
+    if (!name) {
+        return;
+    }
+    const lower = name.toLowerCase();
+    if (lower === 'content-type' || lower === 'contenttype') {
+        output.headers.ContentType = value;
+        return;
+    }
+    if (lower === 'authorization') {
+        output.headers.Authorization = value;
+        return;
+    }
+    output.headers[name] = value;
+}
+function looksLikeJson(value) {
+    const trimmed = value.trim();
+    return (trimmed.startsWith('{') && trimmed.endsWith('}')) || (trimmed.startsWith('[') && trimmed.endsWith(']'));
+}
+function pickString(record, keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === 'string' && value.trim()) {
+            return value.trim();
+        }
+    }
+    return undefined;
+}
+function unquote(value) {
+    const trimmed = value.trim();
+    const quote = trimmed[0];
+    if ((quote === "'" || quote === '"' || quote === '`') && trimmed.endsWith(quote) && trimmed.length >= 2) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+function extractBalanced(source, start, open, close) {
+    if (source[start] !== open) {
+        return null;
+    }
+    let depth = 0;
+    let quote = null;
+    let escaped = false;
+    for (let i = start; i < source.length; i += 1) {
+        const ch = source[i] ?? '';
+        if (quote) {
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (ch === '\\') {
+                escaped = true;
+                continue;
+            }
+            if (ch === quote) {
+                quote = null;
+            }
+            continue;
+        }
+        if (ch === '"' || ch === "'" || ch === '`') {
+            quote = ch;
+            continue;
+        }
+        if (ch === open) {
+            depth += 1;
+        }
+        else if (ch === close) {
+            depth -= 1;
+            if (depth === 0) {
+                return source.slice(start, i + 1);
+            }
+        }
+    }
+    return null;
+}
+function encodeBase64(value) {
+    if (typeof btoa !== 'function') {
+        return value;
+    }
+    const bytes = new TextEncoder().encode(value);
+    let binary = '';
+    bytes.forEach((byte) => {
+        binary += String.fromCharCode(byte);
+    });
+    return btoa(binary);
+}
+function newTempId() {
+    return String(Math.random());
+}
+//#endregion
+
+//#endregion
+//#region ----- Platform Management Widgets Provider -----
+const WIDGETS = [AXMRestApiGeneratorWidget];
+class AXMPlatformManagementWidgetsProvider {
+    getWidgets() {
+        return WIDGETS;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMPlatformManagementWidgetsProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMPlatformManagementWidgetsProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMPlatformManagementWidgetsProvider, decorators: [{
+            type: Injectable
+        }] });
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Feature Definition Provider   ----
+/**
+ * Platform Management Feature Definition Provider.
+ * Provides feature definitions for the Platform Management module.
+ */
+class AXPPlatformManagementFeatureDefinitionProvider {
+    async provide(context) {
+        context.addFeature(AXPPlatformManagementFeatureKeys.MenuCustomization, {
+            title: '@platform-management:features.menu-customization.title',
+            description: '@platform-management:features.menu-customization.description',
+            defaultValue: true,
+            type: 'boolean',
+        });
+        context.addFeature(AXPPlatformManagementFeatureKeys.AutoCheckUpdates, {
+            title: '@platform-management:features.auto-check-updates.title',
+            description: '@platform-management:features.auto-check-updates.description',
+            defaultValue: true,
+            type: 'boolean',
+        });
+        context.addFeature(AXPPlatformManagementFeatureKeys.MaxTokens, {
+            title: '@platform-management:features.max-tokens.title',
+            description: '@platform-management:features.max-tokens.description',
+            defaultValue: 100,
+            type: 'number',
+            interface: {
+                type: 'number-editor',
+                options: {
+                    min: 1,
+                    max: 1000,
+                    step: 1,
+                },
+            },
+        });
+    }
+}
+//#endregion
+
+//#region ----   Menu Customization Constants   ----
+/**
+ * Setting key for menu customizations
+ */
+const AXP_MENU_CUSTOMIZATION_KEY = 'axp.platform-management.menu-customization';
+/**
+ * Current version of menu customization schema
+ */
+const AXP_MENU_CUSTOMIZATION_VERSION = '1.0.0';
+/**
+ * Default menu customization
+ */
+const AXP_MENU_CUSTOMIZATION_DEFAULT = {
+    version: AXP_MENU_CUSTOMIZATION_VERSION,
+    overrides: {},
+    customItems: [],
+};
+/**
+ * Menu management feature configuration
+ */
+const MenuManagementConfig = {
+    route: 'menus',
+    title: `@${RootConfig.config.i18n}:menu-management.components.menu-list.title`,
+    icon: 'fa-light fa-bars',
+};
+//#endregion
+
+//#region ----   Custom Menu Middleware   ----
+/**
+ * Middleware that applies menu customizations using the enhanced context API
+ * Applies user/tenant customizations from settings with priority support
+ */
+class AXPCustomMenuMiddleware {
+    constructor() {
+        //#region ----   Middleware Properties   ----
+        this.name = 'menu-customization';
+        this.priority = 100; // High priority to apply customizations early
+        //#endregion
+        //#region ----   Dependencies   ----
+        this.settingsService = inject(AXPSettingsService);
+        //#endregion
+    }
+    //#endregion
+    //#region ----   Middleware Implementation   ----
+    async process(context) {
+        try {
+            // Load menu customization from settings
+            const customization = await this.loadCustomization();
+            // Apply overrides to existing menu items using context API
+            this.applyOverrides(context, customization);
+            // Add custom menu items
+            this.addCustomItems(context, customization);
+            // Re-sort after applying priority overrides
+            context.sort();
+        }
+        catch (error) {
+            console.error('Error applying menu customizations:', error);
+        }
+    }
+    //#endregion
+    //#region ----   Private Methods   ----
+    /**
+     * Load menu customization from settings
+     * Merges Tenant and User scope customizations (User overrides Tenant)
+     */
+    async loadCustomization() {
+        try {
+            // Load both scopes
+            const tenantSettings = this.settingsService.scope(AXPPlatformScope.Tenant);
+            const userSettings = this.settingsService.scope(AXPPlatformScope.User);
+            const tenantCustomization = await tenantSettings.get(AXP_MENU_CUSTOMIZATION_KEY);
+            const userCustomization = await userSettings.get(AXP_MENU_CUSTOMIZATION_KEY);
+            // Merge customizations: Tenant as base, User overrides
+            const merged = {
+                version: userCustomization?.version || tenantCustomization?.version || AXP_MENU_CUSTOMIZATION_DEFAULT.version,
+                overrides: {
+                    ...(tenantCustomization?.overrides || {}),
+                    ...(userCustomization?.overrides || {}), // User overrides win
+                },
+                customItems: [...(tenantCustomization?.customItems || []), ...(userCustomization?.customItems || [])],
+            };
+            // Return merged result or default if both are empty
+            const hasCustomizations = Object.keys(merged.overrides).length > 0 || merged.customItems.length > 0;
+            return hasCustomizations ? merged : AXP_MENU_CUSTOMIZATION_DEFAULT;
+        }
+        catch (error) {
+            console.error('Failed to load menu customization:', error);
+            return AXP_MENU_CUSTOMIZATION_DEFAULT;
+        }
+    }
+    /**
+     * Apply overrides to existing menu items using enhanced context API
+     */
+    applyOverrides(context, customization) {
+        Object.entries(customization.overrides).forEach(([menuName, override]) => {
+            const finder = context.findByName(menuName);
+            if (!finder.exists()) {
+                return;
+            }
+            // Hide menu item
+            if (override.hidden) {
+                finder.remove();
+                return;
+            }
+            // Apply priority override
+            if (override.priority !== undefined) {
+                finder.setPriority(override.priority);
+            }
+            // Apply property overrides
+            if (override.properties) {
+                finder.update(override.properties);
+            }
+            // Move to different parent
+            if (override.parentName !== undefined) {
+                finder.moveTo(override.parentName);
+            }
+        });
+    }
+    /**
+     * Add custom menu items using context API
+     */
+    addCustomItems(context, customization) {
+        if (customization.customItems && customization.customItems.length > 0) {
+            context.add(...customization.customItems);
+        }
+    }
+}
+//#endregion
+
+/**
+ * Builds a customization key from a scope key
+ * @param scopeKey The scope key (e.g., 'edition:123', 'tenant:456')
+ * @returns The full customization storage key
+ */
+function buildCustomizationKey(scopeKey) {
+    return `${AXP_MENU_CUSTOMIZATION_KEY}.${scopeKey}`;
+}
+//#region ----   Menu Management Service   ----
+/**
+ * Constants for priority calculation
+ */
+const PRIORITY_BASE_ROOT = 0;
+const PRIORITY_BASE_NESTED = 1000;
+const PRIORITY_STEP = 10;
+class AXPMenuManagementService extends AXPMenuCustomizerService {
+    constructor() {
+        super(...arguments);
+        //#region ----   Dependencies   ----
+        this.settingsService = inject(AXPSettingsService);
+        this.menuProviderService = inject(AXPMenuProviderService);
+    }
+    //#endregion
+    //#region ----   AXPMenuCustomizerService Interface Implementation   ----
+    /**
+     * Interface implementation: Get menu tree for the given scope key
+     */
+    async getMenuTree(scopeKey) {
+        return this.getMenuTreeByKey(scopeKey);
+    }
+    /**
+     * Interface implementation: Sync tree changes
+     */
+    async syncTreeChanges(scopeKey, treeNodes) {
+        return this.syncTreeChangesByKey(scopeKey, treeNodes);
+    }
+    /**
+     * Interface implementation: Show menu item
+     */
+    async showMenuItem(scopeKey, menuName) {
+        return this.showMenuItemByKey(scopeKey, menuName);
+    }
+    /**
+     * Interface implementation: Hide menu item
+     */
+    async hideMenuItem(scopeKey, menuName) {
+        return this.hideMenuItemByKey(scopeKey, menuName);
+    }
+    /**
+     * Interface implementation: Add custom menu item
+     */
+    async addCustomMenuItem(scopeKey, menuItem, parentName) {
+        return this.addCustomMenuItemByKey(scopeKey, menuItem, parentName);
+    }
+    /**
+     * Interface implementation: Update custom menu item
+     */
+    async updateCustomMenuItem(scopeKey, menuName, menuItem) {
+        return this.updateCustomMenuItemByKey(scopeKey, menuName, menuItem);
+    }
+    /**
+     * Interface implementation: Update menu properties
+     */
+    async updateMenuProperties(scopeKey, menuName, properties) {
+        return this.updateMenuPropertiesByKey(scopeKey, menuName, properties);
+    }
+    /**
+     * Interface implementation: Delete custom menu item
+     */
+    async deleteCustomMenuItem(scopeKey, menuName) {
+        return this.deleteCustomMenuItemByKey(scopeKey, menuName);
+    }
+    /**
+     * Interface implementation: Reset customizations
+     */
+    async resetCustomizations(scopeKey) {
+        return this.resetCustomizationsByKey(scopeKey);
+    }
+    //#endregion
+    //#region ----   Scope-Based Public Methods   ----
+    /**
+     * Get menu tree as AXTreeViewNode[] for ax-tree-view component (scope-based)
+     */
+    async getMenuTreeByScope(scope) {
+        // Get RAW menu items WITHOUT middleware (for management purposes)
+        const baseItems = await this.menuProviderService.rawItems();
+        // Load customizations for the given scope
+        const customization = await this.loadCustomization(scope);
+        // Merge custom items with base items
+        const allItems = [...baseItems, ...customization.customItems];
+        // Apply parent overrides to restructure items BEFORE building tree
+        const restructuredItems = this.applyParentOverrides(allItems, customization);
+        // Convert to tree nodes with metadata
+        return this.convertToTreeNodes(restructuredItems, customization);
+    }
+    /**
+     * Sync tree changes back to customization (scope-based)
+     * Called automatically when tree structure changes via drag-drop
+     */
+    async syncTreeChangesByScope(scope, treeNodes) {
+        const customization = await this.loadCustomization(scope);
+        // Extract and update priorities and parent relationships from tree structure
+        this.updateCustomizationFromTree(treeNodes, customization);
+        await this.saveCustomization(scope, customization);
+    }
+    /**
+     * Load menu customization for a specific scope
+     */
+    async loadCustomization(scope) {
+        try {
+            const scopedSettings = this.settingsService.scope(scope);
+            const saved = await scopedSettings.get(AXP_MENU_CUSTOMIZATION_KEY);
+            if (saved && saved.version) {
+                return saved;
+            }
+            return cloneDeep(AXP_MENU_CUSTOMIZATION_DEFAULT);
+        }
+        catch {
+            return cloneDeep(AXP_MENU_CUSTOMIZATION_DEFAULT);
+        }
+    }
+    /**
+     * Save menu customization for a specific scope
+     */
+    async saveCustomization(scope, customization) {
+        const scopedSettings = this.settingsService.scope(scope);
+        await scopedSettings.set(AXP_MENU_CUSTOMIZATION_KEY, customization);
+        // Clear menu cache to force reload
+        this.menuProviderService.clearCache();
+    }
+    /**
+     * Hide a menu item (scope-based)
+     */
+    async hideMenuItemByScope(scope, menuName) {
+        this.validateMenuName(menuName, 'hide');
+        const customization = await this.loadCustomization(scope);
+        this.ensureOverrideExists(customization, menuName);
+        customization.overrides[menuName].hidden = true;
+        await this.saveCustomization(scope, customization);
+    }
+    /**
+     * Show a menu item (scope-based)
+     */
+    async showMenuItemByScope(scope, menuName) {
+        this.validateMenuName(menuName, 'show');
+        const customization = await this.loadCustomization(scope);
+        if (customization.overrides[menuName]) {
+            delete customization.overrides[menuName].hidden;
+            this.cleanupEmptyOverride(customization, menuName);
+        }
+        await this.saveCustomization(scope, customization);
+    }
+    /**
+     * Update menu item priority (scope-based)
+     */
+    async updateMenuPriorityByScope(scope, menuName, priority) {
+        this.validateMenuName(menuName, 'update priority for');
+        const customization = await this.loadCustomization(scope);
+        this.ensureOverrideExists(customization, menuName);
+        customization.overrides[menuName].priority = priority;
+        await this.saveCustomization(scope, customization);
+    }
+    /**
+     * Update menu item properties (scope-based)
+     */
+    async updateMenuPropertiesByScope(scope, menuName, properties) {
+        this.validateMenuName(menuName, 'update properties for');
+        const customization = await this.loadCustomization(scope);
+        this.ensureOverrideExists(customization, menuName);
+        customization.overrides[menuName].properties = {
+            ...customization.overrides[menuName].properties,
+            ...properties,
+        };
+        await this.saveCustomization(scope, customization);
+    }
+    /**
+     * Add custom menu item (scope-based)
+     */
+    async addCustomMenuItemByScope(scope, menuItem, parent) {
+        const customization = await this.loadCustomization(scope);
+        // Generate unique name if not provided
+        if (!menuItem.name) {
+            menuItem.name = `custom-menu-${Date.now()}`;
+        }
+        customization.customItems.push(menuItem);
+        await this.saveCustomization(scope, customization);
+    }
+    /**
+     * Update custom menu item (scope-based)
+     */
+    async updateCustomMenuItemByScope(scope, menuName, menuItem) {
+        this.validateMenuName(menuName, 'update');
+        const customization = await this.loadCustomization(scope);
+        const index = customization.customItems.findIndex((item) => item.name === menuName);
+        if (index === -1) {
+            throw new Error(`Custom menu item '${menuName}' not found`);
+        }
+        customization.customItems[index] = menuItem;
+        await this.saveCustomization(scope, customization);
+    }
+    /**
+     * Delete custom menu item (scope-based)
+     */
+    async deleteCustomMenuItemByScope(scope, menuName) {
+        this.validateMenuName(menuName, 'delete');
+        const customization = await this.loadCustomization(scope);
+        const initialLength = customization.customItems.length;
+        customization.customItems = customization.customItems.filter((item) => item.name !== menuName);
+        if (customization.customItems.length === initialLength) {
+            throw new Error(`Custom menu item '${menuName}' not found`);
+        }
+        await this.saveCustomization(scope, customization);
+    }
+    /**
+     * Reset all customizations for a scope (scope-based)
+     */
+    async resetCustomizationsByScope(scope) {
+        await this.saveCustomization(scope, cloneDeep(AXP_MENU_CUSTOMIZATION_DEFAULT));
+    }
+    //#endregion
+    //#region ----   Key-Based Public Methods   ----
+    /**
+     * Get menu tree using a generic scope key (e.g., 'edition:123', 'tenant:456')
+     */
+    async getMenuTreeByKey(scopeKey) {
+        // Get RAW menu items WITHOUT middleware (for management purposes)
+        const baseItems = await this.menuProviderService.rawItems();
+        // Load customizations for the given scope key
+        const customization = await this.loadCustomizationByKey(scopeKey);
+        // Merge custom items with base items
+        const allItems = [...baseItems, ...customization.customItems];
+        // Apply parent overrides to restructure items BEFORE building tree
+        const restructuredItems = this.applyParentOverrides(allItems, customization);
+        // Convert to tree nodes with metadata
+        return this.convertToTreeNodes(restructuredItems, customization);
+    }
+    /**
+     * Sync tree changes using a generic scope key
+     */
+    async syncTreeChangesByKey(scopeKey, treeNodes) {
+        const customization = await this.loadCustomizationByKey(scopeKey);
+        // Extract and update priorities and parent relationships from tree structure
+        this.updateCustomizationFromTree(treeNodes, customization);
+        await this.saveCustomizationByKey(scopeKey, customization);
+    }
+    /**
+     * Load menu customization using a generic scope key
+     */
+    async loadCustomizationByKey(scopeKey) {
+        try {
+            const storageKey = buildCustomizationKey(scopeKey);
+            const scopedSettings = this.settingsService.scope(AXPPlatformScope.Tenant);
+            const saved = await scopedSettings.get(storageKey);
+            if (saved && saved.version) {
+                return saved;
+            }
+            return cloneDeep(AXP_MENU_CUSTOMIZATION_DEFAULT);
+        }
+        catch {
+            return cloneDeep(AXP_MENU_CUSTOMIZATION_DEFAULT);
+        }
+    }
+    /**
+     * Save menu customization using a generic scope key
+     */
+    async saveCustomizationByKey(scopeKey, customization) {
+        const storageKey = buildCustomizationKey(scopeKey);
+        const scopedSettings = this.settingsService.scope(AXPPlatformScope.Tenant);
+        await scopedSettings.set(storageKey, customization);
+        // Clear menu cache to force reload
+        this.menuProviderService.clearCache();
+    }
+    /**
+     * Hide a menu item using a generic scope key
+     */
+    async hideMenuItemByKey(scopeKey, menuName) {
+        this.validateMenuName(menuName, 'hide');
+        const customization = await this.loadCustomizationByKey(scopeKey);
+        this.ensureOverrideExists(customization, menuName);
+        customization.overrides[menuName].hidden = true;
+        await this.saveCustomizationByKey(scopeKey, customization);
+    }
+    /**
+     * Show a menu item using a generic scope key
+     */
+    async showMenuItemByKey(scopeKey, menuName) {
+        this.validateMenuName(menuName, 'show');
+        const customization = await this.loadCustomizationByKey(scopeKey);
+        if (customization.overrides[menuName]) {
+            delete customization.overrides[menuName].hidden;
+            this.cleanupEmptyOverride(customization, menuName);
+        }
+        await this.saveCustomizationByKey(scopeKey, customization);
+    }
+    /**
+     * Update menu item properties using a generic scope key
+     */
+    async updateMenuPropertiesByKey(scopeKey, menuName, properties) {
+        this.validateMenuName(menuName, 'update properties for');
+        const customization = await this.loadCustomizationByKey(scopeKey);
+        this.ensureOverrideExists(customization, menuName);
+        customization.overrides[menuName].properties = {
+            ...customization.overrides[menuName].properties,
+            ...properties,
+        };
+        await this.saveCustomizationByKey(scopeKey, customization);
+    }
+    /**
+     * Add custom menu item using a generic scope key
+     */
+    async addCustomMenuItemByKey(scopeKey, menuItem, parent) {
+        const customization = await this.loadCustomizationByKey(scopeKey);
+        // Generate unique name if not provided
+        if (!menuItem.name) {
+            menuItem.name = `custom-menu-${Date.now()}`;
+        }
+        customization.customItems.push(menuItem);
+        await this.saveCustomizationByKey(scopeKey, customization);
+    }
+    /**
+     * Update custom menu item using a generic scope key
+     */
+    async updateCustomMenuItemByKey(scopeKey, menuName, menuItem) {
+        this.validateMenuName(menuName, 'update');
+        const customization = await this.loadCustomizationByKey(scopeKey);
+        const index = customization.customItems.findIndex((item) => item.name === menuName);
+        if (index === -1) {
+            throw new Error(`Custom menu item '${menuName}' not found`);
+        }
+        customization.customItems[index] = menuItem;
+        await this.saveCustomizationByKey(scopeKey, customization);
+    }
+    /**
+     * Delete custom menu item using a generic scope key
+     */
+    async deleteCustomMenuItemByKey(scopeKey, menuName) {
+        this.validateMenuName(menuName, 'delete');
+        const customization = await this.loadCustomizationByKey(scopeKey);
+        const initialLength = customization.customItems.length;
+        customization.customItems = customization.customItems.filter((item) => item.name !== menuName);
+        if (customization.customItems.length === initialLength) {
+            throw new Error(`Custom menu item '${menuName}' not found`);
+        }
+        await this.saveCustomizationByKey(scopeKey, customization);
+    }
+    /**
+     * Reset all customizations using a generic scope key
+     */
+    async resetCustomizationsByKey(scopeKey) {
+        await this.saveCustomizationByKey(scopeKey, cloneDeep(AXP_MENU_CUSTOMIZATION_DEFAULT));
+    }
+    //#endregion
+    //#region ----   Private Methods   ----
+    /**
+     * Apply parent overrides from customization to restructure menu items
+     * This ensures the tree reflects saved parent changes (moves)
+     */
+    applyParentOverrides(items, customization) {
+        // First, flatten all items into a map for easy lookup
+        const itemMap = this.flattenMenuItems(items);
+        // Build new structure based on effective parent relationships
+        const rootItems = [];
+        const childrenMap = new Map();
+        for (const [itemName, item] of itemMap.entries()) {
+            const override = customization.overrides[itemName];
+            // Determine effective parent (override takes precedence)
+            let effectiveParent;
+            if (override?.parentName !== undefined) {
+                // parentName is explicitly set (could be null for root, or a parent name)
+                effectiveParent = override.parentName;
+            }
+            else {
+                // No override - find original parent by searching original structure
+                effectiveParent = this.findOriginalParent(items, itemName);
+            }
+            if (effectiveParent === null || effectiveParent === undefined) {
+                // Root level item
+                rootItems.push(item);
+            }
+            else {
+                // Child item - add to parent's children
+                if (!childrenMap.has(effectiveParent)) {
+                    childrenMap.set(effectiveParent, []);
+                }
+                childrenMap.get(effectiveParent).push(item);
+            }
+        }
+        // Attach children to their parents recursively
+        const attachChildren = (item) => {
+            if (item.name && childrenMap.has(item.name)) {
+                item.children = childrenMap.get(item.name);
+                item.children?.forEach(attachChildren);
+            }
+        };
+        rootItems.forEach(attachChildren);
+        return rootItems;
+    }
+    /**
+     * Find the original parent name of an item in the original structure
+     * Returns undefined for root items, string for items with parents, null for not found
+     */
+    findOriginalParent(items, targetName, currentParent) {
+        for (const item of items) {
+            if (item.name === targetName) {
+                return currentParent; // undefined if root, string if has parent
+            }
+            if (item.children) {
+                const found = this.findOriginalParent(item.children, targetName, item.name);
+                if (found !== null) {
+                    // Found in children (could be undefined for root of subtree, or string for nested item)
+                    return found;
+                }
+                // found === null means not found in this subtree, continue searching
+            }
+        }
+        return null; // Not found in this level or any children
+    }
+    /**
+     * Convert menu items to AXTreeNode[] with metadata
+     */
+    convertToTreeNodes(items, customization, parentName) {
+        const nodes = items.map((item) => {
+            const itemName = item.name;
+            const override = itemName ? customization.overrides[itemName] : undefined;
+            const isCustom = itemName ? customization.customItems.some((ci) => ci.name === itemName) : false;
+            // Create metadata
+            const metadata = {
+                isBuiltIn: !isCustom,
+                isCustom,
+                isHidden: override?.hidden || false,
+                originalPriority: item.priority,
+                originalParentName: parentName,
+            };
+            // Apply ALL overrides: priority AND properties (text, icon, description, etc.)
+            const effectivePriority = override?.priority !== undefined ? override.priority : item.priority;
+            const effectiveItem = {
+                ...item,
+                ...override?.properties, // Apply property overrides (text, icon, description)
+                priority: effectivePriority,
+            };
+            // Create tree node data with effective (overridden) values
+            const nodeData = {
+                menuItem: effectiveItem,
+                metadata,
+            };
+            // Create tree node using effective (overridden) values
+            const treeNode = {
+                id: itemName || item.path || this.generateNodeId(),
+                title: effectiveItem.text || effectiveItem.path || 'Unnamed',
+                icon: effectiveItem.icon,
+                expanded: false,
+                selected: false,
+                ['children']: item.children ? this.convertToTreeNodes(item.children, customization, itemName) : undefined,
+                childrenCount: item.children?.length,
+                data: nodeData,
+            };
+            return treeNode;
+        });
+        // Sort by priority
+        nodes.sort((a, b) => {
+            const aPriority = a['data']?.menuItem.priority ?? 0;
+            const bPriority = b['data']?.menuItem.priority ?? 0;
+            return aPriority - bPriority;
+        });
+        return nodes;
+    }
+    /**
+     * Update customization from tree structure
+     * Extracts priorities and parent relationships from tree nodes
+     */
+    updateCustomizationFromTree(treeNodes, customization, parentName) {
+        // Calculate base priority for this level to maintain relative ordering
+        const basePriority = parentName ? PRIORITY_BASE_NESTED : PRIORITY_BASE_ROOT;
+        const priorityStep = PRIORITY_STEP;
+        treeNodes.forEach((node, index) => {
+            const nodeData = node['data'] || null;
+            const menuItem = nodeData?.menuItem;
+            if (menuItem?.name) {
+                this.ensureOverrideExists(customization, menuItem.name);
+                // Calculate new priority based on current position
+                const newPriority = basePriority + index * priorityStep;
+                // Get current effective priority (considering existing overrides)
+                const currentEffectivePriority = customization.overrides[menuItem.name]?.priority ?? nodeData.metadata.originalPriority ?? 0;
+                // Always update priority to reflect current position in tree
+                // This ensures reordering works correctly even after multiple moves
+                if (newPriority !== currentEffectivePriority) {
+                    customization.overrides[menuItem.name].priority = newPriority;
+                }
+                // Determine current effective parent (considering existing overrides)
+                const currentEffectiveParent = customization.overrides[menuItem.name]?.parentName ?? nodeData.metadata.originalParentName;
+                // Update parent relationship if it changed from current effective parent
+                if (parentName !== currentEffectiveParent) {
+                    if (parentName) {
+                        customization.overrides[menuItem.name].parentName = parentName;
+                    }
+                    else {
+                        // Moving to root - set to null (not undefined) so middleware will process it
+                        // moveTo(null) moves the item to root level
+                        customization.overrides[menuItem.name].parentName = null;
+                    }
+                }
+                // Clean up empty overrides
+                this.cleanupEmptyOverride(customization, menuItem.name);
+                // Recursively process children
+                const nodeChildren = node['children'];
+                if (nodeChildren && nodeChildren.length > 0) {
+                    this.updateCustomizationFromTree(nodeChildren, customization, menuItem.name);
+                }
+            }
+        });
+    }
+    /**
+     * Validate menu name before operations
+     */
+    validateMenuName(menuName, operation) {
+        if (!menuName) {
+            throw new Error(`Menu item must have a name to be ${operation}`);
+        }
+    }
+    /**
+     * Ensure override object exists for a menu item
+     */
+    ensureOverrideExists(customization, menuName) {
+        if (!customization.overrides[menuName]) {
+            customization.overrides[menuName] = {};
+        }
+    }
+    /**
+     * Clean up empty override objects
+     */
+    cleanupEmptyOverride(customization, menuName) {
+        if (Object.keys(customization.overrides[menuName] || {}).length === 0) {
+            delete customization.overrides[menuName];
+        }
+    }
+    /**
+     * Flatten menu items recursively into a map
+     */
+    flattenMenuItems(items) {
+        const itemMap = new Map();
+        const flatten = (itemList) => {
+            for (const item of itemList) {
+                if (item.name) {
+                    // Clone item without children to rebuild structure
+                    itemMap.set(item.name, { ...item, children: undefined });
+                }
+                if (item.children) {
+                    flatten(item.children);
+                }
+            }
+        };
+        flatten(items);
+        return itemMap;
+    }
+    /**
+     * Generate unique ID for tree nodes
+     */
+    generateNodeId() {
+        return `node-${Date.now()}-${Math.floor(Math.random() * 10000)}`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPMenuManagementService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPMenuManagementService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPMenuManagementService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Module   ----
+/**
+ * Module for menu management features including the menu customizer command.
+ */
+class AXMMenuManagementModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMMenuManagementModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "22.0.8", ngImport: i0, type: AXMMenuManagementModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMMenuManagementModule, providers: [
+            {
+                provide: AXP_MENU_CUSTOMIZER_SERVICE,
+                useExisting: AXPMenuManagementService,
+            },
+            provideCommandSetups([
+                {
+                    key: 'customize-menu',
+                    command: () => import('./acorex-platform-module-platform-management-client-customize-menu.command-2319iHsD.mjs').then((c) => c.AXMCustomizeMenuCommand),
+                },
+            ]),
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMMenuManagementModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [
+                        {
+                            provide: AXP_MENU_CUSTOMIZER_SERVICE,
+                            useExisting: AXPMenuManagementService,
+                        },
+                        provideCommandSetups([
+                            {
+                                key: 'customize-menu',
+                                command: () => import('./acorex-platform-module-platform-management-client-customize-menu.command-2319iHsD.mjs').then((c) => c.AXMCustomizeMenuCommand),
+                            },
+                        ]),
+                    ],
+                }]
+        }] });
+
+/**
+ * Token that returns current ISO date-time string.
+ */
+class AXMTokenProvider {
+    constructor() {
+        this.name = 'now';
+        this.title = 'Now';
+        this.description = 'Current date and time in ISO format';
+    }
+    execute() {
+        return Promise.resolve(new Date().toISOString());
+    }
+}
+
+//#region ----- Imports -----
+//#endregion
+//#region ----- Factory Cache -----
+/**
+ * Global cache for loaded token providers.
+ * Cleared when token entity changes occur.
+ */
+let cachedProviders = null;
+/**
+ * Clears the cached providers, forcing reload on next access.
+ */
+function clearDynamicTokenProvidersCache() {
+    cachedProviders = null;
+}
+//#endregion
+//#region ----- Token Data Access -----
+/**
+ * Resolves the token entity data accessor after the current DI cycle completes.
+ * AXPEntityService cannot be resolved synchronously from the dynamic token provider
+ * factory because AXP_TOKEN_DEFINITION_PROVIDER is still being constructed (cycle via
+ * AXPTokenDefinitionService and expression evaluator scope providers).
+ */
+async function getTokenEntityDataAccessor(injector) {
+    await Promise.resolve();
+    return injector
+        .get(AXPEntityService)
+        .withEntity(RootConfig.module.name, RootConfig.entities.token.name)
+        .data();
+}
+//#endregion
+//#region ----- Factory Function -----
+/**
+ * Factory function that loads tokens from backend and creates providers for each.
+ * Value resolution always runs on the server (`PlatformManagement.Tokens:Resolve`).
+ */
+async function createDynamicTokenProviders(injector) {
+    if (cachedProviders) {
+        return cachedProviders;
+    }
+    cachedProviders = loadTokenProviders(injector);
+    return cachedProviders;
+}
+async function loadTokenProviders(injector) {
+    const sessionService = injector.get(AXPSessionService);
+    if (!sessionService.isReadyForAppScopedApi) {
+        return [];
+    }
+    const tokensService = await getTokenEntityDataAccessor(injector);
+    try {
+        const queryResult = await tokensService.query({
+            skip: 0,
+            take: 1000,
+        });
+        if (!queryResult?.items?.length) {
+            return [];
+        }
+        return queryResult.items.map((token) => createTokenProvider(token, injector));
+    }
+    catch (error) {
+        console.error('[DynamicTokenProvider] Failed to load tokens from backend:', error);
+        throw error;
+    }
+}
+/**
+ * Creates a token provider that resolves values via the server command.
+ */
+function createTokenProvider(token, injector) {
+    const tokenName = token.name;
+    return {
+        name: tokenName,
+        title: token.title,
+        description: token.description,
+        async execute() {
+            const commandExecutor = injector.get(AXPCommandExecutor);
+            const result = await commandExecutor.execute(AXM_TOKEN_RESOLVE_COMMAND_KEY, { tokenName });
+            const __single_result = runtimeCommandPayloadData(result);
+            if (!__single_result || __single_result.value === undefined || __single_result.value === null) {
+                const text = result?.message?.text;
+                const message = (typeof text === 'string' && text) ||
+                    `Token "${tokenName}" not found or returned no value`;
+                throw new Error(message);
+            }
+            return __single_result.value;
+        },
+    };
+}
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Token Refresh Event Listener   ----
+/**
+ * Event listener provider that listens to token entity changes
+ * and clears the token cache when tokens are updated, inserted, or deleted.
+ */
+class AXMTokenRefreshProvider {
+    constructor() {
+        this.tokenService = inject(AXPTokenDefinitionService);
+        /**
+         * Event keys to listen to for token entity changes.
+         * Supports wildcard patterns for entity events.
+         * Format: entity.{operation}.{ModuleName}.{EntityName}
+         * Example: entity.updated.PlatformManagement.Tokens
+         */
+        this.key = `entity.*.${RootConfig.module.name}.${RootConfig.entities.token.name}`;
+    }
+    /**
+     * Executes when a token entity event occurs (inserted, updated, or deleted).
+     * Clears both the token definition service cache and the dynamic providers cache.
+     */
+    async execute(data) {
+        // Clear token definition service cache
+        this.tokenService.clearDefinitionsCache();
+        // Clear dynamic token providers cache to force reload
+        clearDynamicTokenProvidersCache();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMTokenRefreshProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMTokenRefreshProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMTokenRefreshProvider, decorators: [{
+            type: Injectable
+        }] });
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Token Module   ----
+/**
+ * Token feature module.
+ * Provides token definition providers (static and dynamic) and refresh listeners.
+ */
+class AXMTokenModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMTokenModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "22.0.8", ngImport: i0, type: AXMTokenModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMTokenModule, providers: [
+            // Static token provider (built-in tokens)
+            {
+                provide: AXP_TOKEN_DEFINITION_PROVIDER,
+                useClass: AXMTokenProvider,
+                multi: true,
+            },
+            // Dynamic token provider (tokens from backend)
+            {
+                provide: AXP_TOKEN_DEFINITION_PROVIDER,
+                useFactory: (injector) => createDynamicTokenProviders(injector),
+                deps: [Injector],
+                multi: true,
+            },
+            // Token refresh listener (clears cache on entity changes)
+            {
+                provide: AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER,
+                useClass: AXMTokenRefreshProvider,
+                multi: true,
+            },
+            // Execute token command
+            provideCommandSetups([
+                {
+                    key: `${RootConfig.module.name}.${RootConfig.entities.token.name}:Execute`,
+                    command: () => import('./acorex-platform-module-platform-management-client-execute-token.command-DNuHR-0y.mjs').then((c) => c.ExecuteTokenCommand),
+                },
+            ]),
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMTokenModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        // Static token provider (built-in tokens)
+                        {
+                            provide: AXP_TOKEN_DEFINITION_PROVIDER,
+                            useClass: AXMTokenProvider,
+                            multi: true,
+                        },
+                        // Dynamic token provider (tokens from backend)
+                        {
+                            provide: AXP_TOKEN_DEFINITION_PROVIDER,
+                            useFactory: (injector) => createDynamicTokenProviders(injector),
+                            deps: [Injector],
+                            multi: true,
+                        },
+                        // Token refresh listener (clears cache on entity changes)
+                        {
+                            provide: AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER,
+                            useClass: AXMTokenRefreshProvider,
+                            multi: true,
+                        },
+                        // Execute token command
+                        provideCommandSetups([
+                            {
+                                key: `${RootConfig.module.name}.${RootConfig.entities.token.name}:Execute`,
+                                command: () => import('./acorex-platform-module-platform-management-client-execute-token.command-DNuHR-0y.mjs').then((c) => c.ExecuteTokenCommand),
+                            },
+                        ]),
+                    ],
+                }]
+        }] });
+
+class AXPUpdaterService {
+    constructor() {
+        const swUpdate = inject(SwUpdate, { optional: true });
+        const dialogService = inject(AXDialogService);
+        const translateService = inject(AXTranslationService);
+        if (swUpdate?.isEnabled) {
+            swUpdate.versionUpdates.subscribe((event) => {
+                if (event.type === 'VERSION_READY') {
+                    console.log('New version available');
+                    const scope = RootConfig.config.i18n;
+                    const dialog = dialogService.open({
+                        icon: 'fa-regular fa-info',
+                        content: translateService.translateSync('updater.content', { scope: scope }),
+                        title: translateService.translateSync('updater.title', { scope: scope }),
+                        type: 'primary',
+                        orientation: 'horizontal',
+                        buttons: [
+                            {
+                                text: translateService.translateSync('updater.update', { scope: scope }),
+                                color: 'primary',
+                                onClick: async (e) => {
+                                    try {
+                                        document.location.reload();
+                                        dialog.close();
+                                    }
+                                    catch (error) {
+                                        console.error(error);
+                                    }
+                                },
+                            },
+                            {
+                                text: translateService.translateSync('updater.cancel', { scope: scope }),
+                                color: 'default',
+                                autofocus: true,
+                                onClick: (e) => {
+                                    dialog.close();
+                                },
+                            },
+                        ],
+                        closeButton: false,
+                    });
+                }
+            });
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPUpdaterService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPUpdaterService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPUpdaterService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+
+class AXMUpdaterModule {
+    constructor(updaterService) {
+        this.updaterService = updaterService;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMUpdaterModule, deps: [{ token: AXPUpdaterService }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "22.0.8", ngImport: i0, type: AXMUpdaterModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMUpdaterModule, providers: [AXPUpdaterService] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMUpdaterModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [],
+                    declarations: [],
+                    providers: [AXPUpdaterService],
+                }]
+        }], ctorParameters: () => [{ type: AXPUpdaterService }] });
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Manifest Definition   ----
+/**
+ * Platform Management Module Manifest.
+ * Defines module metadata, features, and provider references.
+ */
+const PlatformManagementManifest = {
+    name: RootConfig.module.name,
+    version: '1.0.0',
+    title: RootConfig.module.title,
+    icon: RootConfig.module.icon,
+    i18n: RootConfig.config.i18n,
+    type: 'platform',
+    domain: 'platform',
+    dependencies: [
+        'SecurityManagement',
+        'ApplicationManagement',
+        'SystemInsight',
+        'TenantManagement',
+        'SubscriptionManagement',
+    ],
+};
+//#endregion
+
+class AXMMenuProvider {
+    constructor() {
+        this.entityService = inject(AXPEntityService);
+    }
+    async provide(context) {
+        const scope = RootConfig.config.i18n;
+        const moduleName = RootConfig.module.name;
+        const platformShellPolicy = {
+            features: [moduleName],
+            permissions: [AXPApplicationsPlatformPermissionKeys.MaintainPlatformShell],
+        };
+        //#region ----- Platform > Tokens -----
+        context.find(AXPCommonMenuKeys.Platform).addItems([
+            {
+                name: AXPPlatformManagementMenuKeys.Tokens,
+                priority: 8,
+                text: `@${scope}:tokens.terms.tokens`,
+                path: this.entityService.createPath(moduleName, RootConfig.entities.token.name),
+                icon: RootConfig.entities.token.icon,
+                policy: platformShellPolicy,
+            },
+        ]);
+        //#endregion
+        //#region ----- Configuration > Platform Definitions -----
+        const platformDefinitionsMenu = context.find(AXPCommonMenuKeys.PlatformDefinitions);
+        if (!platformDefinitionsMenu.exists) {
+            context.find(AXPCommonMenuKeys.Configuration).addItems([
+                {
+                    name: AXPCommonMenuKeys.PlatformDefinitions,
+                    priority: 8946,
+                    text: '@general:menus.platform-definitions.title',
+                    icon: 'fa-light fa-books',
+                    type: 'menu',
+                    children: [],
+                    policy: platformShellPolicy,
+                },
+            ]);
+        }
+        context.find(AXPCommonMenuKeys.PlatformDefinitions).addItems([
+            {
+                name: AXPPlatformManagementMenuKeys.EntityDefinitions,
+                text: `@${scope}:menus.entity-definitions.title`,
+                path: this.entityService.createPath(moduleName, RootConfig.entities.entityDefinition.name),
+                icon: RootConfig.entities.entityDefinition.icon,
+                priority: 1,
+                policy: platformShellPolicy,
+            },
+            {
+                name: AXPPlatformManagementMenuKeys.CommandDefinitions,
+                text: `@${scope}:menus.command-definitions.title`,
+                path: this.entityService.createPath(moduleName, RootConfig.entities.commandDefinition.name),
+                icon: RootConfig.entities.commandDefinition.icon,
+                priority: 2,
+                policy: platformShellPolicy,
+            },
+            {
+                name: AXPPlatformManagementMenuKeys.QueryDefinitions,
+                text: `@${scope}:menus.query-definitions.title`,
+                path: this.entityService.createPath(moduleName, RootConfig.entities.queryDefinition.name),
+                icon: RootConfig.entities.queryDefinition.icon,
+                priority: 3,
+                policy: platformShellPolicy,
+            },
+            {
+                name: AXPPlatformManagementMenuKeys.PluginDefinitions,
+                text: `@${scope}:menus.plugin-definitions.title`,
+                path: this.entityService.createPath(moduleName, RootConfig.entities.pluginDefinition.name),
+                icon: RootConfig.entities.pluginDefinition.icon,
+                priority: 4,
+                policy: platformShellPolicy,
+            },
+            {
+                name: AXPPlatformManagementMenuKeys.Widgets,
+                text: `@${scope}:menus.widgets.title`,
+                path: this.entityService.createPath(moduleName, RootConfig.entities.widget.name),
+                icon: RootConfig.entities.widget.icon,
+                priority: 5,
+                policy: platformShellPolicy,
+            },
+        ]);
+        //#endregion
+    }
+}
+
+//#endregion
+//#region ---- Permission Definition Provider ----
+/**
+ * Registers MaintainPlatformShell under Applications & Platform.
+ */
+class AXMPermissionDefinitionProvider {
+    async define(context) {
+        const keys = AXPApplicationsPlatformPermissionKeys;
+        const groups = AXPCommonPermissionGroupKeys;
+        const P = '@common:applications-platform.permissions';
+        const G = '@common:permission-groups';
+        context.addGroup(groups.ApplicationsPlatform.Root, `${G}.applications-platform.title`, `${G}.applications-platform.description`, { order: 110 });
+        context
+            .addGroup(groups.ApplicationsPlatform.TenancyShell, `${G}.applications-platform-tenancy-shell.title`, `${G}.applications-platform-tenancy-shell.description`, { parent: groups.ApplicationsPlatform.Root, order: 20 })
+            .addPermission(keys.MaintainPlatformShell, `${P}.maintain-platform-shell.title`, `${P}.maintain-platform-shell.description`, { modules: ['PlatformManagement'], requiredFeatures: ['PlatformManagement'] })
+            .endPermission()
+            .endGroup();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMPermissionDefinitionProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMPermissionDefinitionProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMPermissionDefinitionProvider, decorators: [{
+            type: Injectable
+        }] });
+
+//#region ---- Entity row → registry record ----
+function mapEntityRowToRegistryRecord(row) {
+    return {
+        name: row.name,
+        active: row.active !== false,
+        description: row.description,
+        catalogTitle: row.catalogTitle,
+        executionMode: row.executionMode,
+        capabilities: row.capabilities,
+        inputOptionDefinitions: row.inputOptionDefinitions,
+        outputOptionDefinitions: row.outputOptionDefinitions,
+        outcomesDefinitionJson: row.outcomesDefinitionJson,
+        aiMetadataJson: row.aiMetadataJson,
+        categories: row.categories,
+    };
+}
+//#endregion
+//#region ---- Platform command catalog CRUD (server-backed) ----
+/**
+ * Reads command catalog metadata from {@code PlatformManagement.CommandDefinition} entity storage (server DB).
+ * Sidecar source files are never imported in the browser bundle.
+ */
+class AXMPlatformCommandCatalogCrudService {
+    constructor() {
+        this.entityService = inject(AXPEntityService);
+    }
+    entityData() {
+        return this.entityService
+            .withEntity(RootConfig.module.name, RootConfig.entities.commandDefinition.name)
+            .data();
+    }
+    async listCommands() {
+        const result = await this.entityData().query({ skip: 0, take: 5000 });
+        const items = (result.items ?? []);
+        return items.map((row) => ({
+            id: String(row.id),
+            definition: mapEntityRowToRegistryRecord(row),
+        }));
+    }
+    async getCommand(id) {
+        const row = await this.entityData().byKey(id);
+        return row ? mapEntityRowToRegistryRecord(row) : null;
+    }
+    // #region ---- Unimplemented catalog stores (Phase 1: commands only) ----
+    async list() {
+        return [];
+    }
+    async getRaw() {
+        return null;
+    }
+    async create() {
+        throw new Error('Entity definition CRUD is not available for command catalog rows.');
+    }
+    async update() {
+        throw new Error('Entity definition CRUD is not available for command catalog rows.');
+    }
+    async delete() {
+        throw new Error('Entity definition CRUD is not available for command catalog rows.');
+    }
+    async listInterfaces() {
+        return [];
+    }
+    async listInterfacesByCategory() {
+        return [];
+    }
+    async getInterface() {
+        return null;
+    }
+    async createInterface() {
+        throw new Error('Not implemented');
+    }
+    async updateInterface() {
+        throw new Error('Not implemented');
+    }
+    async deleteInterface() {
+        throw new Error('Not implemented');
+    }
+    async listPlugins() {
+        return [];
+    }
+    async getPlugin() {
+        return null;
+    }
+    async createPlugin() {
+        throw new Error('Not implemented');
+    }
+    async updatePlugin() {
+        throw new Error('Not implemented');
+    }
+    async deletePlugin() {
+        throw new Error('Not implemented');
+    }
+    async listValidations() {
+        return [];
+    }
+    async getValidation() {
+        return null;
+    }
+    async createValidation() {
+        throw new Error('Not implemented');
+    }
+    async updateValidation() {
+        throw new Error('Not implemented');
+    }
+    async deleteValidation() {
+        throw new Error('Not implemented');
+    }
+    async listRelations() {
+        return [];
+    }
+    async getRelation() {
+        return null;
+    }
+    async createRelation() {
+        throw new Error('Not implemented');
+    }
+    async updateRelation() {
+        throw new Error('Not implemented');
+    }
+    async deleteRelation() {
+        throw new Error('Not implemented');
+    }
+    async listModules() {
+        return [];
+    }
+    async getModule() {
+        return null;
+    }
+    async createModule() {
+        throw new Error('Not implemented');
+    }
+    async updateModule() {
+        throw new Error('Not implemented');
+    }
+    async deleteModule() {
+        throw new Error('Not implemented');
+    }
+    async listAggregates() {
+        return [];
+    }
+    async getAggregate() {
+        return null;
+    }
+    async createAggregate() {
+        throw new Error('Not implemented');
+    }
+    async updateAggregate() {
+        throw new Error('Not implemented');
+    }
+    async deleteAggregate() {
+        throw new Error('Not implemented');
+    }
+    async listMenus() {
+        return [];
+    }
+    async getMenu() {
+        return null;
+    }
+    async createMenu() {
+        throw new Error('Not implemented');
+    }
+    async updateMenu() {
+        throw new Error('Not implemented');
+    }
+    async deleteMenu() {
+        throw new Error('Not implemented');
+    }
+    async listPermissionGroups() {
+        return [];
+    }
+    async getPermissionGroup() {
+        return null;
+    }
+    async createPermissionGroup() {
+        throw new Error('Not implemented');
+    }
+    async updatePermissionGroup() {
+        throw new Error('Not implemented');
+    }
+    async deletePermissionGroup() {
+        throw new Error('Not implemented');
+    }
+    async createCommand() {
+        throw new Error('Not implemented');
+    }
+    async updateCommand() {
+        throw new Error('Not implemented');
+    }
+    async deleteCommand() {
+        throw new Error('Not implemented');
+    }
+    async listQueries() {
+        return [];
+    }
+    async getQuery() {
+        return null;
+    }
+    async createQuery() {
+        throw new Error('Not implemented');
+    }
+    async updateQuery() {
+        throw new Error('Not implemented');
+    }
+    async deleteQuery() {
+        throw new Error('Not implemented');
+    }
+    async listWidgets() {
+        return [];
+    }
+    async getWidget() {
+        return null;
+    }
+    async createWidget() {
+        throw new Error('Not implemented');
+    }
+    async updateWidget() {
+        throw new Error('Not implemented');
+    }
+    async deleteWidget() {
+        throw new Error('Not implemented');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMPlatformCommandCatalogCrudService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMPlatformCommandCatalogCrudService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMPlatformCommandCatalogCrudService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+function providePlatformCommandCatalogCrudService() {
+    return {
+        provide: AXP_ENTITY_DEFINITION_CRUD_SERVICE,
+        useExisting: AXMPlatformCommandCatalogCrudService,
+    };
+}
+
+// Entity Modules
+//#region ----   Routes Factory   ----
+function routesFactory() {
+    return [
+        {
+            path: ':app/platform-management/menus/:scope',
+            canActivate: [...AXP_PROTECTED_ROUTE_GUARDS],
+            data: { rootLayout: true },
+            loadComponent: () => AXPRootLayoutComponent,
+            children: [
+                {
+                    path: '',
+                    loadComponent: () => import('./acorex-platform-module-platform-management-client-menu-list.component-C5HH5-Dw.mjs').then((c) => c.AXMMenuListComponent),
+                    data: { reuse: true },
+                },
+            ],
+        },
+    ];
+}
+//#endregion
+class AXMPlatformManagementModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMPlatformManagementModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "22.0.8", ngImport: i0, type: AXMPlatformManagementModule, imports: [AXPWidgetCoreModule,
+            AXMUpdaterModule,
+            AXMTokenModule,
+            AXMMenuManagementModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMPlatformManagementModule, providers: [
+            // Module-specific providers (not part of manifest system)
+            {
+                provide: AXP_MENU_MIDDLEWARE,
+                useClass: AXPCustomMenuMiddleware,
+                multi: true,
+            },
+            {
+                provide: ROUTES,
+                multi: true,
+                useFactory: routesFactory,
+            },
+            // Module Manifest Provider
+            {
+                provide: AXP_MODULE_MANIFEST_PROVIDER,
+                useValue: PlatformManagementManifest,
+                multi: true,
+            },
+            // Provider references (now using tokens)
+            {
+                provide: AXP_PERMISSION_DEFINITION_PROVIDER,
+                useClass: AXMPermissionDefinitionProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_MENU_PROVIDER,
+                useClass: AXMMenuProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_FEATURE_DEFINITION_PROVIDER,
+                useClass: AXPPlatformManagementFeatureDefinitionProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_WIDGET_DEFINITION_PROVIDER,
+                useClass: AXMPlatformManagementWidgetsProvider,
+                multi: true,
+            },
+            providePlatformCommandCatalogCrudService(),
+            provideCommandSetups([
+                {
+                    key: 'PlatformManagement:DataListPickEntityItem',
+                    command: () => import('./acorex-platform-module-platform-management-client-data-list-pick-entity-item.command-CJVpqPmY.mjs').then((c) => c.AXPDataListPickEntityItemCommand),
+                },
+                {
+                    key: 'PlatformManagement:CreateUserQuery',
+                    command: () => import('./acorex-platform-module-platform-management-client-create-user-query.command-2Qu7aoCp.mjs').then((c) => c.AXMCreateUserQueryCommand),
+                },
+            ]),
+            provideQuerySetups([
+                {
+                    key: 'PlatformManagement:ListRegisteredEntities',
+                    loader: () => import('./acorex-platform-module-platform-management-client-list-registered-entities.query-DjStd3a8.mjs').then((c) => c.AXMListRegisteredEntitiesQuery),
+                },
+                {
+                    key: 'PlatformManagement:ListRegisteredQueries',
+                    loader: () => import('./acorex-platform-module-platform-management-client-list-registered-queries.query-C-IfkTel.mjs').then((c) => c.AXMListRegisteredQueriesQuery),
+                },
+                {
+                    key: 'PlatformManagement:ListPlatformNavigationForAi',
+                    loader: () => import('./acorex-platform-module-platform-management-client-list-platform-navigation-for-ai.query-2oHMITw-.mjs').then((c) => c.AXMListPlatformNavigationForAiQuery),
+                },
+                {
+                    key: 'PlatformManagement:ListCatalogScopes',
+                    loader: () => import('./acorex-platform-module-platform-management-client-list-catalog-scopes.query-ByhDTWE6.mjs').then((c) => c.AXMListCatalogScopesQuery),
+                },
+                {
+                    key: 'PlatformManagement:ListEditorWidgets',
+                    loader: () => import('./acorex-platform-module-platform-management-client-list-editor-widgets.query-DITPMmbw.mjs').then((c) => c.AXMListEditorWidgetsQuery),
+                },
+                {
+                    key: 'PlatformManagement:Dashboard:TenantsKpi',
+                    loader: () => import('./acorex-platform-module-platform-management-client-platform-console-kpi.queries-BkPdhVq_.mjs').then((c) => c.AXMPlatformTenantsKpiQuery),
+                },
+                {
+                    key: 'PlatformManagement:Dashboard:UsersKpi',
+                    loader: () => import('./acorex-platform-module-platform-management-client-platform-console-kpi.queries-BkPdhVq_.mjs').then((c) => c.AXMPlatformUsersKpiQuery),
+                },
+                {
+                    key: 'PlatformManagement:Dashboard:ApplicationsKpi',
+                    loader: () => import('./acorex-platform-module-platform-management-client-platform-console-kpi.queries-BkPdhVq_.mjs').then((c) => c.AXMPlatformApplicationsKpiQuery),
+                },
+                {
+                    key: 'PlatformManagement:Dashboard:ErrorsKpi',
+                    loader: () => import('./acorex-platform-module-platform-management-client-platform-console-kpi.queries-BkPdhVq_.mjs').then((c) => c.AXMPlatformErrorsKpiQuery),
+                },
+                {
+                    key: 'PlatformManagement:Dashboard:TenantsByStatusBar',
+                    loader: () => import('./acorex-platform-module-platform-management-client-platform-console-charts.queries-CQ34R13-.mjs').then((c) => c.AXMPlatformTenantsByStatusBarQuery),
+                },
+                {
+                    key: 'PlatformManagement:Dashboard:ApplicationsByEditionDonut',
+                    loader: () => import('./acorex-platform-module-platform-management-client-platform-console-charts.queries-CQ34R13-.mjs').then((c) => c.AXMPlatformApplicationsByEditionDonutQuery),
+                },
+                {
+                    key: 'PlatformManagement:Dashboard:ErrorsTrendLine',
+                    loader: () => import('./acorex-platform-module-platform-management-client-platform-console-charts.queries-CQ34R13-.mjs').then((c) => c.AXMPlatformErrorsTrendLineQuery),
+                },
+                {
+                    key: 'PlatformManagement:Dashboard:JobsByStatusBar',
+                    loader: () => import('./acorex-platform-module-platform-management-client-platform-console-charts.queries-CQ34R13-.mjs').then((c) => c.AXMPlatformJobsByStatusBarQuery),
+                },
+            ]),
+        ], imports: [AXPWidgetCoreModule,
+            AXMUpdaterModule,
+            AXMTokenModule,
+            AXMMenuManagementModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMPlatformManagementModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        AXPWidgetCoreModule,
+                        AXMUpdaterModule,
+                        AXMTokenModule,
+                        AXMMenuManagementModule,
+                        // Entity Modules
+                    ],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        // Module-specific providers (not part of manifest system)
+                        {
+                            provide: AXP_MENU_MIDDLEWARE,
+                            useClass: AXPCustomMenuMiddleware,
+                            multi: true,
+                        },
+                        {
+                            provide: ROUTES,
+                            multi: true,
+                            useFactory: routesFactory,
+                        },
+                        // Module Manifest Provider
+                        {
+                            provide: AXP_MODULE_MANIFEST_PROVIDER,
+                            useValue: PlatformManagementManifest,
+                            multi: true,
+                        },
+                        // Provider references (now using tokens)
+                        {
+                            provide: AXP_PERMISSION_DEFINITION_PROVIDER,
+                            useClass: AXMPermissionDefinitionProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_MENU_PROVIDER,
+                            useClass: AXMMenuProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_FEATURE_DEFINITION_PROVIDER,
+                            useClass: AXPPlatformManagementFeatureDefinitionProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_WIDGET_DEFINITION_PROVIDER,
+                            useClass: AXMPlatformManagementWidgetsProvider,
+                            multi: true,
+                        },
+                        providePlatformCommandCatalogCrudService(),
+                        provideCommandSetups([
+                            {
+                                key: 'PlatformManagement:DataListPickEntityItem',
+                                command: () => import('./acorex-platform-module-platform-management-client-data-list-pick-entity-item.command-CJVpqPmY.mjs').then((c) => c.AXPDataListPickEntityItemCommand),
+                            },
+                            {
+                                key: 'PlatformManagement:CreateUserQuery',
+                                command: () => import('./acorex-platform-module-platform-management-client-create-user-query.command-2Qu7aoCp.mjs').then((c) => c.AXMCreateUserQueryCommand),
+                            },
+                        ]),
+                        provideQuerySetups([
+                            {
+                                key: 'PlatformManagement:ListRegisteredEntities',
+                                loader: () => import('./acorex-platform-module-platform-management-client-list-registered-entities.query-DjStd3a8.mjs').then((c) => c.AXMListRegisteredEntitiesQuery),
+                            },
+                            {
+                                key: 'PlatformManagement:ListRegisteredQueries',
+                                loader: () => import('./acorex-platform-module-platform-management-client-list-registered-queries.query-C-IfkTel.mjs').then((c) => c.AXMListRegisteredQueriesQuery),
+                            },
+                            {
+                                key: 'PlatformManagement:ListPlatformNavigationForAi',
+                                loader: () => import('./acorex-platform-module-platform-management-client-list-platform-navigation-for-ai.query-2oHMITw-.mjs').then((c) => c.AXMListPlatformNavigationForAiQuery),
+                            },
+                            {
+                                key: 'PlatformManagement:ListCatalogScopes',
+                                loader: () => import('./acorex-platform-module-platform-management-client-list-catalog-scopes.query-ByhDTWE6.mjs').then((c) => c.AXMListCatalogScopesQuery),
+                            },
+                            {
+                                key: 'PlatformManagement:ListEditorWidgets',
+                                loader: () => import('./acorex-platform-module-platform-management-client-list-editor-widgets.query-DITPMmbw.mjs').then((c) => c.AXMListEditorWidgetsQuery),
+                            },
+                            {
+                                key: 'PlatformManagement:Dashboard:TenantsKpi',
+                                loader: () => import('./acorex-platform-module-platform-management-client-platform-console-kpi.queries-BkPdhVq_.mjs').then((c) => c.AXMPlatformTenantsKpiQuery),
+                            },
+                            {
+                                key: 'PlatformManagement:Dashboard:UsersKpi',
+                                loader: () => import('./acorex-platform-module-platform-management-client-platform-console-kpi.queries-BkPdhVq_.mjs').then((c) => c.AXMPlatformUsersKpiQuery),
+                            },
+                            {
+                                key: 'PlatformManagement:Dashboard:ApplicationsKpi',
+                                loader: () => import('./acorex-platform-module-platform-management-client-platform-console-kpi.queries-BkPdhVq_.mjs').then((c) => c.AXMPlatformApplicationsKpiQuery),
+                            },
+                            {
+                                key: 'PlatformManagement:Dashboard:ErrorsKpi',
+                                loader: () => import('./acorex-platform-module-platform-management-client-platform-console-kpi.queries-BkPdhVq_.mjs').then((c) => c.AXMPlatformErrorsKpiQuery),
+                            },
+                            {
+                                key: 'PlatformManagement:Dashboard:TenantsByStatusBar',
+                                loader: () => import('./acorex-platform-module-platform-management-client-platform-console-charts.queries-CQ34R13-.mjs').then((c) => c.AXMPlatformTenantsByStatusBarQuery),
+                            },
+                            {
+                                key: 'PlatformManagement:Dashboard:ApplicationsByEditionDonut',
+                                loader: () => import('./acorex-platform-module-platform-management-client-platform-console-charts.queries-CQ34R13-.mjs').then((c) => c.AXMPlatformApplicationsByEditionDonutQuery),
+                            },
+                            {
+                                key: 'PlatformManagement:Dashboard:ErrorsTrendLine',
+                                loader: () => import('./acorex-platform-module-platform-management-client-platform-console-charts.queries-CQ34R13-.mjs').then((c) => c.AXMPlatformErrorsTrendLineQuery),
+                            },
+                            {
+                                key: 'PlatformManagement:Dashboard:JobsByStatusBar',
+                                loader: () => import('./acorex-platform-module-platform-management-client-platform-console-charts.queries-CQ34R13-.mjs').then((c) => c.AXMPlatformJobsByStatusBarQuery),
+                            },
+                        ]),
+                    ],
+                }]
+        }] });
+
+/** MIME type for native drag payloads carrying `AXPWorkflowActivityPaletteItem` JSON. */
+const AXP_WORKFLOW_PALETTE_MIME = 'application/x-axp-workflow-palette-item';
+
+//#region ---- Ids ----
+let idCounter = 0;
+function createWorkflowNodeId() {
+    idCounter += 1;
+    return `wf-node-${Date.now()}-${idCounter}`;
+}
+function createWorkflowConnectorId() {
+    idCounter += 1;
+    return `wf-conn-${Date.now()}-${idCounter}`;
+}
+function createWorkflowPortId(prefix) {
+    idCounter += 1;
+    return `${prefix}-port-${idCounter}`;
+}
+//#endregion
+//#region ---- Defaults ----
+const DEFAULT_SIZE = { width: 180, height: 72 };
+const DEFAULT_INBOUND = [{ side: 'left', ratio: 0.5, key: 'in' }];
+const DEFAULT_OUTBOUND = [{ side: 'right', ratio: 0.5, key: 'out' }];
+function cloneDiagram(model) {
+    return {
+        nodes: model.nodes.map((n) => ({
+            ...n,
+            position: { ...n.position },
+            size: { ...n.size },
+            inboundPorts: n.inboundPorts.map((p) => ({
+                ...p,
+                data: p.data ? { ...p.data } : undefined,
+            })),
+            outboundPorts: n.outboundPorts.map((p) => ({
+                ...p,
+                data: p.data ? { ...p.data } : undefined,
+            })),
+            data: n.data ? { ...n.data } : undefined,
+        })),
+        connectors: model.connectors.map((c) => ({
+            ...c,
+            data: c.data ? { ...c.data } : undefined,
+        })),
+        data: model.data ? { ...model.data } : undefined,
+    };
+}
+function createPortsFromPalette(nodeId, item) {
+    const inboundSrc = item.inboundPorts !== undefined ? item.inboundPorts : DEFAULT_INBOUND;
+    const outboundSrc = item.outboundPorts !== undefined ? item.outboundPorts : DEFAULT_OUTBOUND;
+    const inbound = inboundSrc.map((p) => ({
+        ...p,
+        id: createWorkflowPortId(`${nodeId}-in`),
+        kind: 'inbound',
+        data: p.data ? { ...p.data } : undefined,
+    }));
+    const outbound = outboundSrc.map((p) => ({
+        ...p,
+        id: createWorkflowPortId(`${nodeId}-out`),
+        kind: 'outbound',
+        data: p.data ? { ...p.data } : undefined,
+    }));
+    return { inbound, outbound };
+}
+function createNodeFromPaletteItem(item, position) {
+    const id = createWorkflowNodeId();
+    const { inbound, outbound } = createPortsFromPalette(id, item);
+    const shape = item.shape ?? 'rounded-rectangle';
+    const size = item.size ? { ...item.size } : { ...DEFAULT_SIZE };
+    if (shape === 'circle') {
+        const d = Math.min(size.width, size.height);
+        size.width = d;
+        size.height = d;
+    }
+    return {
+        id,
+        type: item.type,
+        title: item.title,
+        icon: item.icon,
+        shape,
+        position: { ...position },
+        size: { ...size },
+        inboundPorts: inbound,
+        outboundPorts: outbound,
+        data: item.data ? { ...item.data } : undefined,
+        lockAspectRatio: item.lockAspectRatio ?? shape === 'circle',
+        snapToGrid: item.snapToGrid,
+        color: item.color,
+    };
+}
+/**
+ * Parses drag `dataTransfer` JSON into a partial palette item (requires `type`).
+ * Merge with catalog (`paletteItems`) to obtain `title` and defaults.
+ */
+function parsePaletteItemDragPayload(raw) {
+    if (!raw)
+        return null;
+    try {
+        const o = JSON.parse(raw);
+        if (typeof o.type !== 'string')
+            return null;
+        return o;
+    }
+    catch {
+        return null;
+    }
+}
+//#endregion
+//#region ---- Snap ----
+function snapScalar(value, grid) {
+    if (grid <= 0)
+        return value;
+    return Math.round(value / grid) * grid;
+}
+function snapPoint(point, grid) {
+    return { x: snapScalar(point.x, grid), y: snapScalar(point.y, grid) };
+}
+//#endregion
+//#region ---- Port anchor (node-local, top-left origin) ----
+/**
+ * Inbound/outbound anchor on an axis-aligned ellipse inscribed in `w`×`h` (centered),
+ * so ports sit on the true perimeter for circle/ellipse nodes.
+ */
+function portAnchorOnEllipsePerimeter(w, h, side, ratio) {
+    const r = Math.min(0.999, Math.max(0.001, ratio));
+    const cx = w * 0.5;
+    const cy = h * 0.5;
+    const rx = w * 0.5;
+    const ry = h * 0.5;
+    let theta = 0;
+    switch (side) {
+        case 'right':
+            theta = -Math.PI / 2 + Math.PI * r;
+            break;
+        case 'left':
+            theta = Math.PI / 2 + Math.PI * r;
+            break;
+        case 'top':
+            theta = Math.PI + Math.PI * r;
+            break;
+        case 'bottom':
+            theta = Math.PI * r;
+            break;
+        default:
+            theta = 0;
+    }
+    return {
+        x: cx + rx * Math.cos(theta),
+        y: cy + ry * Math.sin(theta),
+    };
+}
+function portAnchorOnBoxEdge(w, h, side, ratio) {
+    const r = Math.min(0.999, Math.max(0.001, ratio));
+    switch (side) {
+        case 'top':
+            return { x: w * r, y: 0 };
+        case 'bottom':
+            return { x: w * r, y: h };
+        case 'left':
+            return { x: 0, y: h * r };
+        case 'right':
+            return { x: w, y: h * r };
+        default:
+            return { x: w * 0.5, y: h * 0.5 };
+    }
+}
+/** Diamond perimeter of a rotated square inside the node bounds. */
+function portAnchorOnDiamondPerimeter(w, h, side, ratio) {
+    const r = Math.min(0.999, Math.max(0.001, ratio));
+    const top = { x: w * 0.5, y: 0 };
+    const right = { x: w, y: h * 0.5 };
+    const bottom = { x: w * 0.5, y: h };
+    const left = { x: 0, y: h * 0.5 };
+    const lerp = (a, b, t) => ({
+        x: a.x + (b.x - a.x) * t,
+        y: a.y + (b.y - a.y) * t,
+    });
+    switch (side) {
+        case 'top':
+            return r <= 0.5 ? lerp(left, top, r * 2) : lerp(top, right, (r - 0.5) * 2);
+        case 'right':
+            return r <= 0.5 ? lerp(top, right, r * 2) : lerp(right, bottom, (r - 0.5) * 2);
+        case 'bottom':
+            return r <= 0.5 ? lerp(right, bottom, r * 2) : lerp(bottom, left, (r - 0.5) * 2);
+        case 'left':
+            return r <= 0.5 ? lerp(bottom, left, r * 2) : lerp(left, top, (r - 0.5) * 2);
+        default:
+            return { x: w * 0.5, y: h * 0.5 };
+    }
+}
+function portAnchorOnNode(node, port) {
+    const { width: w, height: h } = node.size;
+    const r = Math.min(0.999, Math.max(0.001, port.ratio));
+    if (node.shape === 'circle' || node.shape === 'ellipse') {
+        return portAnchorOnEllipsePerimeter(w, h, port.side, r);
+    }
+    if (node.shape === 'diamond') {
+        return portAnchorOnDiamondPerimeter(w, h, port.side, r);
+    }
+    return portAnchorOnBoxEdge(w, h, port.side, r);
+}
+function portCanvasPosition(node, port) {
+    const local = portAnchorOnNode(node, port);
+    return { x: node.position.x + local.x, y: node.position.y + local.y };
+}
+function inflateRect(r, padding) {
+    return {
+        x: r.position.x - padding,
+        y: r.position.y - padding,
+        width: r.size.width + padding * 2,
+        height: r.size.height + padding * 2,
+    };
+}
+function pointInsideRect(p, r) {
+    return p.x > r.x && p.x < r.x + r.width && p.y > r.y && p.y < r.y + r.height;
+}
+/**
+ * Returns true if an axis-aligned segment crosses the interior of any obstacle.
+ * Endpoints that only touch the rectangle's edge are not considered a crossing.
+ */
+function segmentCrossesObstacles(a, b, obstacles) {
+    const minX = Math.min(a.x, b.x);
+    const maxX = Math.max(a.x, b.x);
+    const minY = Math.min(a.y, b.y);
+    const maxY = Math.max(a.y, b.y);
+    const tolerance = 0.5;
+    for (const r of obstacles) {
+        const right = r.x + r.width;
+        const bottom = r.y + r.height;
+        if (maxX <= r.x + tolerance || minX >= right - tolerance)
+            continue;
+        if (maxY <= r.y + tolerance || minY >= bottom - tolerance)
+            continue;
+        if (Math.abs(a.y - b.y) < 0.0001) {
+            if (a.y > r.y + tolerance && a.y < bottom - tolerance)
+                return true;
+        }
+        else if (Math.abs(a.x - b.x) < 0.0001) {
+            if (a.x > r.x + tolerance && a.x < right - tolerance)
+                return true;
+        }
+        else {
+            return true;
+        }
+    }
+    return false;
+}
+function stepOutward(p, side, length) {
+    switch (side) {
+        case 'left':
+            return { x: p.x - length, y: p.y };
+        case 'right':
+            return { x: p.x + length, y: p.y };
+        case 'top':
+            return { x: p.x, y: p.y - length };
+        case 'bottom':
+            return { x: p.x, y: p.y + length };
+    }
+}
+function oppositeSide(side) {
+    switch (side) {
+        case 'left':
+            return 'right';
+        case 'right':
+            return 'left';
+        case 'top':
+            return 'bottom';
+        case 'bottom':
+            return 'top';
+    }
+}
+function sideAxis(side) {
+    return side === 'left' || side === 'right' ? 'h' : 'v';
+}
+/**
+ * Removes consecutive duplicate points and collapses collinear intermediate waypoints.
+ */
+function simplifyWaypoints(points) {
+    const deduped = [];
+    for (const p of points) {
+        const last = deduped[deduped.length - 1];
+        if (last && Math.abs(last.x - p.x) < 0.001 && Math.abs(last.y - p.y) < 0.001)
+            continue;
+        deduped.push(p);
+    }
+    if (deduped.length <= 2)
+        return deduped;
+    const out = [deduped[0]];
+    for (let i = 1; i < deduped.length - 1; i++) {
+        const prev = deduped[i - 1];
+        const curr = deduped[i];
+        const next = deduped[i + 1];
+        const collinearH = Math.abs(prev.y - curr.y) < 0.001 && Math.abs(curr.y - next.y) < 0.001;
+        const collinearV = Math.abs(prev.x - curr.x) < 0.001 && Math.abs(curr.x - next.x) < 0.001;
+        if (!collinearH && !collinearV)
+            out.push(curr);
+    }
+    out.push(deduped[deduped.length - 1]);
+    return out;
+}
+/**
+ * Generates candidate waypoint sets that connect `a` to `b` while respecting the entry/exit axes.
+ * Strategies are ordered from "most natural" to "more elaborate detour".
+ */
+function generateRouteStrategies(a, aAxis, b, bAxis, obstacles) {
+    const strategies = [];
+    const midX = (a.x + b.x) / 2;
+    const midY = (a.y + b.y) / 2;
+    const obstacleXCuts = [];
+    const obstacleYCuts = [];
+    for (const o of obstacles) {
+        obstacleXCuts.push(o.x - 6);
+        obstacleXCuts.push(o.x + o.width + 6);
+        obstacleYCuts.push(o.y - 6);
+        obstacleYCuts.push(o.y + o.height + 6);
+    }
+    obstacleXCuts.sort((x, y) => Math.abs(x - midX) - Math.abs(y - midX));
+    obstacleYCuts.sort((x, y) => Math.abs(x - midY) - Math.abs(y - midY));
+    if (aAxis === 'h' && bAxis === 'h') {
+        strategies.push([
+            { x: midX, y: a.y },
+            { x: midX, y: b.y },
+        ]);
+        for (const mx of obstacleXCuts) {
+            strategies.push([
+                { x: mx, y: a.y },
+                { x: mx, y: b.y },
+            ]);
+        }
+        for (const my of obstacleYCuts) {
+            strategies.push([
+                { x: a.x, y: my },
+                { x: b.x, y: my },
+            ]);
+        }
+    }
+    else if (aAxis === 'v' && bAxis === 'v') {
+        strategies.push([
+            { x: a.x, y: midY },
+            { x: b.x, y: midY },
+        ]);
+        for (const my of obstacleYCuts) {
+            strategies.push([
+                { x: a.x, y: my },
+                { x: b.x, y: my },
+            ]);
+        }
+        for (const mx of obstacleXCuts) {
+            strategies.push([
+                { x: mx, y: a.y },
+                { x: mx, y: b.y },
+            ]);
+        }
+    }
+    else if (aAxis === 'h' && bAxis === 'v') {
+        strategies.push([{ x: b.x, y: a.y }]);
+        for (const my of obstacleYCuts) {
+            strategies.push([
+                { x: a.x, y: my },
+                { x: b.x, y: my },
+            ]);
+        }
+    }
+    else {
+        strategies.push([{ x: a.x, y: b.y }]);
+        for (const mx of obstacleXCuts) {
+            strategies.push([
+                { x: mx, y: a.y },
+                { x: mx, y: b.y },
+            ]);
+        }
+    }
+    return strategies;
+}
+/**
+ * Picks the first strategy whose segments do not cross any obstacle.
+ * Falls back to the most natural strategy when every candidate is blocked
+ * (best-effort: keeps the connector readable even in tight layouts).
+ */
+function pickCleanStrategy(a, b, strategies, obstacles) {
+    for (const wp of strategies) {
+        const full = [a, ...wp, b];
+        let clean = true;
+        for (let i = 0; i < full.length - 1; i++) {
+            if (segmentCrossesObstacles(full[i], full[i + 1], obstacles)) {
+                clean = false;
+                break;
+            }
+        }
+        if (clean)
+            return wp;
+    }
+    return strategies[0] ?? [];
+}
+/**
+ * Routes an obstacle-aware orthogonal path between two free-space points.
+ * The returned array includes the start (`from`), stub-outs from each port,
+ * intermediate waypoints, and the end (`to`).
+ *
+ * Obstacles whose inflated rect already contains a stub point are dropped so
+ * that source/target nodes can still emit/receive their connector without the
+ * router fighting itself — but the middle of the path still routes around them.
+ */
+function routeOrthogonalConnector(from, sourceSide, to, targetSide, obstacles = [], options = {}) {
+    const stub = Math.max(0, options.stub ?? 18);
+    const padding = Math.max(0, options.obstaclePadding ?? 10);
+    const aStub = stepOutward(from, sourceSide, stub);
+    const bStub = stepOutward(to, targetSide, stub);
+    const inflated = obstacles.map((o) => inflateRect(o, padding));
+    const safe = inflated.filter((o) => !pointInsideRect(aStub, o) && !pointInsideRect(bStub, o));
+    const strategies = generateRouteStrategies(aStub, sideAxis(sourceSide), bStub, sideAxis(targetSide), safe);
+    const middle = pickCleanStrategy(aStub, bStub, strategies, safe);
+    return simplifyWaypoints([from, aStub, ...middle, bStub, to]);
+}
+/** Renders waypoints as straight `L` segments. */
+function waypointsToOrthogonalPath(points) {
+    if (points.length < 2)
+        return '';
+    const cmds = [`M ${points[0].x} ${points[0].y}`];
+    for (let i = 1; i < points.length; i++) {
+        cmds.push(`L ${points[i].x} ${points[i].y}`);
+    }
+    return cmds.join(' ');
+}
+/** Renders waypoints with rounded corners (quadratic curves) between segments. */
+function waypointsToRoundedPath(points, radius) {
+    if (points.length < 2)
+        return '';
+    if (points.length === 2)
+        return `M ${points[0].x} ${points[0].y} L ${points[1].x} ${points[1].y}`;
+    const cmds = [`M ${points[0].x} ${points[0].y}`];
+    for (let i = 1; i < points.length - 1; i++) {
+        const prev = points[i - 1];
+        const curr = points[i];
+        const next = points[i + 1];
+        const inDx = Math.sign(curr.x - prev.x);
+        const inDy = Math.sign(curr.y - prev.y);
+        const outDx = Math.sign(next.x - curr.x);
+        const outDy = Math.sign(next.y - curr.y);
+        const segIn = Math.hypot(curr.x - prev.x, curr.y - prev.y);
+        const segOut = Math.hypot(next.x - curr.x, next.y - curr.y);
+        const r = Math.max(0, Math.min(radius, segIn * 0.5, segOut * 0.5));
+        const cornerStart = { x: curr.x - inDx * r, y: curr.y - inDy * r };
+        const cornerEnd = { x: curr.x + outDx * r, y: curr.y + outDy * r };
+        cmds.push(`L ${cornerStart.x} ${cornerStart.y}`);
+        cmds.push(`Q ${curr.x} ${curr.y} ${cornerEnd.x} ${cornerEnd.y}`);
+    }
+    const last = points[points.length - 1];
+    cmds.push(`L ${last.x} ${last.y}`);
+    return cmds.join(' ');
+}
+/**
+ * Builds the SVG `d` string for a connector. When `options.obstacles` is supplied,
+ * orthogonal/rounded routes detour around the obstacle rectangles instead of
+ * passing through them. The `straight` style always draws a direct line.
+ */
+function connectorPath(from, to, style, sourceSide, options = {}) {
+    if (style === 'straight') {
+        return `M ${from.x} ${from.y} L ${to.x} ${to.y}`;
+    }
+    const targetSide = options.targetSide ?? oppositeSide(sourceSide);
+    const waypoints = routeOrthogonalConnector(from, sourceSide, to, targetSide, options.obstacles ?? [], {
+        stub: options.stub,
+        obstaclePadding: options.obstaclePadding,
+    });
+    if (style === 'orthogonal') {
+        return waypointsToOrthogonalPath(waypoints);
+    }
+    return waypointsToRoundedPath(waypoints, options.cornerRadius ?? 14);
+}
+//#endregion
+//#region ---- Model helpers ----
+function findNode(model, nodeId) {
+    return model.nodes.find((n) => n.id === nodeId);
+}
+function findPort(node, portId) {
+    const pi = node.inboundPorts.find((p) => p.id === portId);
+    if (pi)
+        return { port: pi, inbound: true };
+    const po = node.outboundPorts.find((p) => p.id === portId);
+    if (po)
+        return { port: po, inbound: false };
+    return undefined;
+}
+function findConnector(model, id) {
+    return model.connectors.find((c) => c.id === id);
+}
+/**
+ * Built-in rules: valid ports, not disabled, optional single inbound attachment, no duplicate edge.
+ */
+function defaultCanConnectRequest(request) {
+    const { model, sourceNodeId, sourcePortId, targetNodeId, targetPortId } = request;
+    const sn = findNode(model, sourceNodeId);
+    const tn = findNode(model, targetNodeId);
+    if (!sn || !tn)
+        return false;
+    const spInfo = findPort(sn, sourcePortId);
+    const tpInfo = findPort(tn, targetPortId);
+    if (!spInfo || !tpInfo)
+        return false;
+    const sp = spInfo.port;
+    const tp = tpInfo.port;
+    if (sp.kind !== 'outbound' || tp.kind !== 'inbound')
+        return false;
+    if (sp.disabled || tp.disabled)
+        return false;
+    const duplicate = model.connectors.some((c) => c.sourceNodeId === sourceNodeId &&
+        c.sourcePortId === sourcePortId &&
+        c.targetNodeId === targetNodeId &&
+        c.targetPortId === targetPortId);
+    if (duplicate)
+        return false;
+    if (!tp.allowMultiple) {
+        const inboundTaken = model.connectors.some((c) => c.targetNodeId === targetNodeId && c.targetPortId === targetPortId);
+        if (inboundTaken)
+            return false;
+    }
+    return true;
+}
+//#endregion
+//#region ---- Auto layout ----
+const DEFAULT_ARRANGE_MARGIN = 80;
+// Defaults leave room for inbound/outbound port labels that sit ~18px outside the
+// port anchor and may extend further as text. Larger gaps keep adjacent nodes from
+// having their port labels collide with each other or with routed connectors.
+const DEFAULT_ARRANGE_PRIMARY_GAP = 160;
+const DEFAULT_ARRANGE_CROSS_GAP = 110;
+const DEFAULT_ARRANGE_COMPONENT_GAP = 220;
+/**
+ * Auto-arranges workflow nodes in a layered layout (left→right by default).
+ * Honors `direction`, `alignment`, `origin`, `nodeIds`, and crossing-reduction options.
+ */
+function arrangeWorkflowDiagram(model, options = {}) {
+    if (model.nodes.length === 0) {
+        return model;
+    }
+    const margin = options.margin ?? DEFAULT_ARRANGE_MARGIN;
+    const runtime = {
+        direction: options.direction ?? 'horizontal',
+        alignment: options.alignment ?? 'center',
+        primaryGap: options.horizontalGap ?? DEFAULT_ARRANGE_PRIMARY_GAP,
+        crossGap: options.verticalGap ?? DEFAULT_ARRANGE_CROSS_GAP,
+        componentGap: Math.max(options.verticalGap ?? DEFAULT_ARRANGE_CROSS_GAP, DEFAULT_ARRANGE_COMPONENT_GAP),
+        margin,
+        grid: options.gridSize ?? 0,
+        origin: options.origin ?? { x: margin, y: margin },
+        reduceCrossings: options.reduceCrossings ?? true,
+        groupDisconnected: options.groupDisconnected ?? true,
+    };
+    const subsetIds = options.nodeIds && options.nodeIds.length > 0
+        ? new Set(options.nodeIds.filter((id) => model.nodes.some((n) => n.id === id)))
+        : null;
+    const targetNodes = subsetIds ? model.nodes.filter((n) => subsetIds.has(n.id)) : model.nodes;
+    if (targetNodes.length === 0) {
+        return model;
+    }
+    const targetIds = new Set(targetNodes.map((n) => n.id));
+    const relevantConnectors = model.connectors.filter((c) => targetIds.has(c.sourceNodeId) && targetIds.has(c.targetNodeId));
+    const components = splitComponents(targetNodes, relevantConnectors, runtime, options.startNodeId);
+    const positionById = new Map();
+    let crossCursor = runtime.direction === 'horizontal' ? runtime.origin.y : runtime.origin.x;
+    for (const component of components) {
+        layoutComponent(component, positionById, runtime, crossCursor);
+        crossCursor += component.crossSize + runtime.componentGap;
+    }
+    return {
+        ...model,
+        nodes: model.nodes.map((n) => {
+            const next = positionById.get(n.id);
+            return next ? { ...n, position: { ...next } } : n;
+        }),
+    };
+}
+function splitComponents(nodes, connectors, runtime, startNodeId) {
+    const undirected = new Map();
+    const outgoing = new Map();
+    const incomingCount = new Map();
+    for (const n of nodes) {
+        undirected.set(n.id, new Set());
+        outgoing.set(n.id, new Set());
+        incomingCount.set(n.id, 0);
+    }
+    for (const c of connectors) {
+        if (!undirected.has(c.sourceNodeId) || !undirected.has(c.targetNodeId))
+            continue;
+        undirected.get(c.sourceNodeId).add(c.targetNodeId);
+        undirected.get(c.targetNodeId).add(c.sourceNodeId);
+        outgoing.get(c.sourceNodeId).add(c.targetNodeId);
+        incomingCount.set(c.targetNodeId, (incomingCount.get(c.targetNodeId) ?? 0) + 1);
+    }
+    const sortedNodes = [...nodes].sort(compareNodesForLayout);
+    if (startNodeId) {
+        sortedNodes.sort((a, b) => {
+            if (a.id === startNodeId)
+                return -1;
+            if (b.id === startNodeId)
+                return 1;
+            return 0;
+        });
+    }
+    const visited = new Set();
+    const componentBuckets = [];
+    if (runtime.groupDisconnected) {
+        for (const seed of sortedNodes) {
+            if (visited.has(seed.id))
+                continue;
+            const bucket = [];
+            const queue = [seed.id];
+            visited.add(seed.id);
+            while (queue.length > 0) {
+                const id = queue.shift();
+                const node = nodes.find((n) => n.id === id);
+                if (node)
+                    bucket.push(node);
+                for (const next of undirected.get(id) ?? []) {
+                    if (!visited.has(next)) {
+                        visited.add(next);
+                        queue.push(next);
+                    }
+                }
+            }
+            componentBuckets.push(bucket);
+        }
+    }
+    else {
+        componentBuckets.push([...nodes]);
+    }
+    const components = [];
+    for (const bucket of componentBuckets) {
+        const bucketIds = new Set(bucket.map((n) => n.id));
+        const bucketConnectors = connectors.filter((c) => bucketIds.has(c.sourceNodeId) && bucketIds.has(c.targetNodeId));
+        const ranks = computeRanks(bucket, outgoing, incomingCount, startNodeId);
+        if (runtime.reduceCrossings) {
+            reduceCrossingsInPlace(ranks, bucketConnectors, runtime.direction);
+        }
+        else {
+            for (const rank of ranks)
+                rank.sort(compareNodesForLayout);
+        }
+        const crossSize = estimateCrossSize(ranks, runtime);
+        components.push({ nodes: bucket, ranks, crossSize });
+    }
+    return components;
+}
+function computeRanks(nodes, outgoing, incomingCount, startNodeId) {
+    const rank = new Map();
+    const queue = [];
+    const enqueueRoots = (ids) => {
+        for (const id of ids) {
+            if (!rank.has(id)) {
+                rank.set(id, 0);
+                queue.push(id);
+            }
+        }
+    };
+    const localIds = new Set(nodes.map((n) => n.id));
+    if (startNodeId && localIds.has(startNodeId)) {
+        enqueueRoots([startNodeId]);
+    }
+    else {
+        enqueueRoots(nodes.filter((n) => (incomingCount.get(n.id) ?? 0) === 0).map((n) => n.id));
+    }
+    // First-visit BFS handles cycles safely (shortest-distance ranking).
+    const maxSteps = nodes.length * (nodes.length + 1);
+    let steps = 0;
+    while (queue.length > 0 && steps < maxSteps) {
+        steps += 1;
+        const id = queue.shift();
+        const base = rank.get(id) ?? 0;
+        for (const targetId of outgoing.get(id) ?? []) {
+            if (!localIds.has(targetId) || rank.has(targetId))
+                continue;
+            rank.set(targetId, base + 1);
+            queue.push(targetId);
+        }
+    }
+    let orphanRank = nodes.reduce((max, n) => Math.max(max, rank.get(n.id) ?? 0), 0) + 1;
+    const unranked = nodes.filter((n) => !rank.has(n.id)).sort(compareNodesForLayout);
+    for (const n of unranked) {
+        rank.set(n.id, orphanRank);
+        orphanRank += 1;
+    }
+    const byRank = new Map();
+    for (const n of nodes) {
+        const r = rank.get(n.id) ?? 0;
+        const bucket = byRank.get(r) ?? [];
+        bucket.push(n);
+        byRank.set(r, bucket);
+    }
+    return [...byRank.keys()].sort((a, b) => a - b).map((r) => byRank.get(r) ?? []);
+}
+/**
+ * Returns a 0–1 fraction along the cross axis (vertical for horizontal flow) where the port sits on the node.
+ */
+function portCrossAxisFraction(node, portId, direction) {
+    const info = findPort(node, portId);
+    if (!info) {
+        return 0.5;
+    }
+    const port = info.port;
+    const r = Math.min(0.999, Math.max(0.001, port.ratio));
+    if (direction === 'horizontal') {
+        switch (port.side) {
+            case 'left':
+            case 'right':
+                return r;
+            case 'top':
+                return 0;
+            case 'bottom':
+                return 1;
+        }
+    }
+    switch (port.side) {
+        case 'top':
+        case 'bottom':
+            return r;
+        case 'left':
+            return 0;
+        case 'right':
+            return 1;
+    }
+    return r;
+}
+/**
+ * Barycenter heuristic with port-aware weights: targets inherit both their predecessor's rank index
+ * and the source port's cross-axis position so top/bottom (or left/right) ports map to matching targets.
+ */
+function reduceCrossingsInPlace(ranks, connectors, direction) {
+    if (ranks.length === 0)
+        return;
+    ranks[0] = [...ranks[0]].sort(compareNodesForLayout);
+    const nodeById = new Map();
+    for (const rank of ranks) {
+        for (const node of rank) {
+            nodeById.set(node.id, node);
+        }
+    }
+    const indexInRank = ranks.map((rank) => {
+        const map = new Map();
+        for (let i = 0; i < rank.length; i++)
+            map.set(rank[i].id, i);
+        return map;
+    });
+    for (let r = 1; r < ranks.length; r++) {
+        const predRank = ranks[r - 1];
+        const predIndex = indexInRank[r - 1];
+        const incomingFromPred = new Map();
+        const predIds = new Set(predRank.map((n) => n.id));
+        for (const c of connectors) {
+            if (!predIds.has(c.sourceNodeId)) {
+                continue;
+            }
+            const idx = predIndex.get(c.sourceNodeId);
+            if (idx === undefined) {
+                continue;
+            }
+            const sourceNode = nodeById.get(c.sourceNodeId);
+            const portFraction = sourceNode ? portCrossAxisFraction(sourceNode, c.sourcePortId, direction) : 0.5;
+            // Keep port ordering within the same predecessor index (fraction ∈ [0, 1)).
+            const weight = idx + portFraction;
+            const arr = incomingFromPred.get(c.targetNodeId) ?? [];
+            arr.push(weight);
+            incomingFromPred.set(c.targetNodeId, arr);
+        }
+        ranks[r] = [...ranks[r]].sort((a, b) => {
+            const ia = incomingFromPred.get(a.id) ?? [];
+            const ib = incomingFromPred.get(b.id) ?? [];
+            const ba = ia.length > 0 ? ia.reduce((s, v) => s + v, 0) / ia.length : Number.POSITIVE_INFINITY;
+            const bb = ib.length > 0 ? ib.reduce((s, v) => s + v, 0) / ib.length : Number.POSITIVE_INFINITY;
+            if (ba !== bb)
+                return ba - bb;
+            return compareNodesForLayout(a, b);
+        });
+        const refreshed = new Map();
+        for (let i = 0; i < ranks[r].length; i++)
+            refreshed.set(ranks[r][i].id, i);
+        indexInRank[r] = refreshed;
+    }
+}
+function estimateCrossSize(ranks, runtime) {
+    let max = 0;
+    for (const rank of ranks) {
+        const total = rank.reduce((sum, n) => sum + (runtime.direction === 'horizontal' ? n.size.height : n.size.width), 0);
+        const gaps = Math.max(0, rank.length - 1) * runtime.crossGap;
+        max = Math.max(max, total + gaps);
+    }
+    return max;
+}
+function layoutComponent(component, positionById, runtime, crossStart) {
+    const isHorizontal = runtime.direction === 'horizontal';
+    let primaryCursor = isHorizontal ? runtime.origin.x : runtime.origin.y;
+    for (const rank of component.ranks) {
+        if (rank.length === 0)
+            continue;
+        const crossTotal = rank.reduce((sum, n) => sum + (isHorizontal ? n.size.height : n.size.width), 0);
+        const crossGaps = (rank.length - 1) * runtime.crossGap;
+        const crossLen = crossTotal + crossGaps;
+        let cursor = crossStart;
+        if (runtime.alignment === 'center') {
+            cursor = crossStart + (component.crossSize - crossLen) * 0.5;
+        }
+        else if (runtime.alignment === 'end') {
+            cursor = crossStart + (component.crossSize - crossLen);
+        }
+        let primaryMax = 0;
+        for (const node of rank) {
+            const primary = isHorizontal ? primaryCursor : cursor;
+            const cross = isHorizontal ? cursor : primaryCursor;
+            const raw = isHorizontal ? { x: primary, y: cross } : { x: cross, y: primary };
+            const snapped = runtime.grid > 0 ? snapPoint(raw, runtime.grid) : raw;
+            positionById.set(node.id, snapped);
+            const advance = (isHorizontal ? node.size.height : node.size.width) + runtime.crossGap;
+            cursor += advance;
+            primaryMax = Math.max(primaryMax, isHorizontal ? node.size.width : node.size.height);
+        }
+        primaryCursor += primaryMax + runtime.primaryGap;
+    }
+}
+function compareNodesForLayout(a, b) {
+    const titleA = a.title?.trim() ?? '';
+    const titleB = b.title?.trim() ?? '';
+    if (titleA !== titleB) {
+        return titleA.localeCompare(titleB);
+    }
+    return a.id.localeCompare(b.id);
+}
+//#endregion
+
+//#endregion
+class AXPWorkflowDesignerComponent {
+    //#endregion
+    constructor() {
+        /** Unique SVG fragment id so multiple designers on one page do not clash. */
+        this.svgMarkerId = `axp-wf-arrow-${Math.random().toString(36).slice(2, 10)}`;
+        //#region ---- Inputs / outputs ----
+        this.model = input.required(/* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "model" }] : /* istanbul ignore next */ []));
+        this.modelChange = output();
+        /** When true, the whole designer is non-interactive unless a nested entity sets its own readonly flag. */
+        this.readonly = input(false, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "readonly" }] : /* istanbul ignore next */ []));
+        /** Read-only run/history views: emphasize nodes (e.g. current workflow step) without selection chrome. */
+        this.highlightedNodeIds = input([], /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "highlightedNodeIds" }] : /* istanbul ignore next */ []));
+        this.gridSize = input(20, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "gridSize" }] : /* istanbul ignore next */ []));
+        /** Default snap when node does not override `snapToGrid`. */
+        this.snapToGrid = input(true, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "snapToGrid" }] : /* istanbul ignore next */ []));
+        this.connectionPreviewStyle = input('orthogonal', /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "connectionPreviewStyle" }] : /* istanbul ignore next */ []));
+        this.backgroundPattern = input('dots', /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "backgroundPattern" }] : /* istanbul ignore next */ []));
+        this.zoomChange = output();
+        /** When set, replaces built-in `defaultCanConnectRequest` entirely. */
+        this.canConnect = input(null, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "canConnect" }] : /* istanbul ignore next */ []));
+        /** Used to resolve native palette drag payloads (`type`) into full defaults. */
+        this.paletteItems = input([], /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "paletteItems" }] : /* istanbul ignore next */ []));
+        /** When false, port labels are hidden (ports remain interactive). */
+        this.showPortLabels = input(true, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "showPortLabels" }] : /* istanbul ignore next */ []));
+        this.nodeBodyTemplate = input(null, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "nodeBodyTemplate" }] : /* istanbul ignore next */ []));
+        this.designerPointerDown = output();
+        this.designerClick = output();
+        this.designerDoubleClick = output();
+        this.nodePointerDown = output();
+        this.nodeClick = output();
+        this.nodeDoubleClick = output();
+        this.nodeContextMenu = output();
+        this.nodeDragStart = output();
+        this.nodeDragEnd = output();
+        this.portPointerDown = output();
+        this.linkDragStart = output();
+        this.linkDragMove = output();
+        this.linkDragEnd = output();
+        this.connectorClick = output();
+        this.connectorDoubleClick = output();
+        this.connectionCreated = output();
+        this.connectionRejected = output();
+        this.activationChange = output();
+        //#endregion
+        //#region ---- State ----
+        this.surfaceRef = viewChild.required('surface', /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "surfaceRef" }] : /* istanbul ignore next */ []));
+        this.panViewRef = viewChild(AXPanViewDirective, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "panViewRef" }] : /* istanbul ignore next */ []));
+        this.activation = signal(null, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "activation" }] : /* istanbul ignore next */ []));
+        this.selectedNodeIds = signal(new Set(), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "selectedNodeIds" }] : /* istanbul ignore next */ []));
+        this.selectedConnectorIds = signal(new Set(), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "selectedConnectorIds" }] : /* istanbul ignore next */ []));
+        this.panX = signal(0, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "panX" }] : /* istanbul ignore next */ []));
+        this.panY = signal(0, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "panY" }] : /* istanbul ignore next */ []));
+        this.panZoomLevel = signal(100, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "panZoomLevel" }] : /* istanbul ignore next */ []));
+        this.linkDrag = signal(null, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "linkDrag" }] : /* istanbul ignore next */ []));
+        /** Inbound port under the pointer while dragging a new connector from an outbound port. */
+        this.linkHoverTarget = signal(null, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "linkHoverTarget" }] : /* istanbul ignore next */ []));
+        this.nodeMove = null;
+        this.resize = null;
+        this.suppressNextNodeClick = false;
+        this.wrapperDragoverListener = null;
+        this.wrapperDropListener = null;
+        this.wrapperElement = signal(null, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "wrapperElement" }] : /* istanbul ignore next */ []));
+        this.wrapperAttachRetryHandle = null;
+        this.wrapperAttachAttempt = 0;
+        this.destroyRef = inject(DestroyRef);
+        //#endregion
+        //#region ---- Computed ----
+        this.gridStyle = computed(() => {
+            const g = this.gridSize();
+            if (this.backgroundPattern() === 'dots') {
+                return {
+                    'background-size': `${g}px ${g}px`,
+                    'background-image': `radial-gradient(circle, rgba(148, 163, 184, 0.35) 1px, transparent 1.2px)`,
+                };
+            }
+            return {
+                'background-size': `${g}px ${g}px`,
+                'background-image': `
+        linear-gradient(to right, rgba(148, 163, 184, 0.2) 1px, transparent 1px),
+        linear-gradient(to bottom, rgba(148, 163, 184, 0.2) 1px, transparent 1px)
+      `,
+            };
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "gridStyle" }] : /* istanbul ignore next */ []));
+        this.canvasViewport = computed(() => {
+            const model = this.model();
+            const contentPadding = 320;
+            const minCanvasWidth = 1600;
+            const minCanvasHeight = 1000;
+            const nodeMinX = model.nodes.reduce((acc, node) => Math.min(acc, node.position.x), 0);
+            const nodeMinY = model.nodes.reduce((acc, node) => Math.min(acc, node.position.y), 0);
+            const nodeMaxRight = model.nodes.reduce((acc, node) => Math.max(acc, node.position.x + node.size.width), 0);
+            const nodeMaxBottom = model.nodes.reduce((acc, node) => Math.max(acc, node.position.y + node.size.height), 0);
+            const minX = Math.min(0, nodeMinX);
+            const minY = Math.min(0, nodeMinY);
+            const maxRight = Math.max(minCanvasWidth, nodeMaxRight);
+            const maxBottom = Math.max(minCanvasHeight, nodeMaxBottom);
+            const offsetX = -minX + contentPadding;
+            const offsetY = -minY + contentPadding;
+            return {
+                minX,
+                minY,
+                offsetX,
+                offsetY,
+                width: Math.ceil(maxRight - minX + contentPadding * 2),
+                height: Math.ceil(maxBottom - minY + contentPadding * 2),
+            };
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "canvasViewport" }] : /* istanbul ignore next */ []));
+        this.surfaceStyle = computed(() => {
+            const viewport = this.canvasViewport();
+            return {
+                // ...this.gridStyle(),
+                width: `${viewport.width}px`,
+                height: `${viewport.height}px`,
+            };
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "surfaceStyle" }] : /* istanbul ignore next */ []));
+        this.onWindowPointerMoveForNode = (ev) => {
+            const drag = this.nodeMove;
+            if (!drag)
+                return;
+            const model = this.model();
+            const p = this.canvasPointFromClient(ev.clientX, ev.clientY);
+            const dx = p.x - drag.start.x;
+            const dy = p.y - drag.start.y;
+            if (Math.abs(dx) > 1 || Math.abs(dy) > 1) {
+                drag.moved = true;
+            }
+            const nodes = model.nodes.map((n) => {
+                if (!drag.nodeIds.includes(n.id))
+                    return n;
+                const origin = drag.origins[n.id];
+                if (!origin)
+                    return n;
+                let nx = origin.x + dx;
+                let ny = origin.y + dy;
+                const snapped = this.applySnapForNode(n, { x: nx, y: ny });
+                nx = snapped.x;
+                ny = snapped.y;
+                return { ...n, position: { x: nx, y: ny } };
+            });
+            this.commit({ ...model, nodes });
+        };
+        this.onWindowPointerUpForNode = (ev) => {
+            const drag = this.nodeMove;
+            this.nodeMove = null;
+            window.removeEventListener('pointermove', this.onWindowPointerMoveForNode);
+            window.removeEventListener('pointerup', this.onWindowPointerUpForNode);
+            window.removeEventListener('pointercancel', this.onWindowPointerUpForNode);
+            if (drag?.moved) {
+                this.suppressNextNodeClick = true;
+            }
+            if (drag) {
+                const node = findNode(this.model(), drag.nodeIds[0] ?? '');
+                if (node)
+                    this.nodeDragEnd.emit({ node, event: ev });
+            }
+        };
+        this.onWindowPointerMoveForResize = (ev) => {
+            const st = this.resize;
+            if (!st)
+                return;
+            const model = this.model();
+            const node = findNode(model, st.nodeId);
+            if (!node)
+                return;
+            const p = this.canvasPointFromClient(ev.clientX, ev.clientY);
+            const dx = p.x - st.startPointer.x;
+            const dy = p.y - st.startPointer.y;
+            let { width, height } = st.startSize;
+            let { x, y } = st.startPosition;
+            const minW = 72;
+            const minH = 40;
+            const growEast = st.handle.includes('e');
+            const growSouth = st.handle.includes('s');
+            const growWest = st.handle.includes('w');
+            const growNorth = st.handle.includes('n');
+            if (growEast)
+                width = Math.max(minW, st.startSize.width + dx);
+            if (growSouth)
+                height = Math.max(minH, st.startSize.height + dy);
+            if (growWest) {
+                const nw = Math.max(minW, st.startSize.width - dx);
+                x = st.startPosition.x + st.startSize.width - nw;
+                width = nw;
+            }
+            if (growNorth) {
+                const nh = Math.max(minH, st.startSize.height - dy);
+                y = st.startPosition.y + st.startSize.height - nh;
+                height = nh;
+            }
+            if (node.shape === 'circle' || node.lockAspectRatio) {
+                const a = st.aspect;
+                if (growEast || growWest) {
+                    height = width / a;
+                    if (growNorth)
+                        y = st.startPosition.y + st.startSize.height - height;
+                }
+                else {
+                    width = height * a;
+                    if (growWest)
+                        x = st.startPosition.x + st.startSize.width - width;
+                }
+            }
+            const g = this.gridSize();
+            const useSnap = node.snapToGrid ?? this.snapToGrid();
+            if (useSnap && g > 0) {
+                width = Math.max(minW, snapScalar(width, g));
+                height = Math.max(minH, snapScalar(height, g));
+                x = snapScalar(x, g);
+                y = snapScalar(y, g);
+            }
+            const nodes = model.nodes.map((n) => n.id === node.id ? { ...n, position: { x, y }, size: { width, height } } : n);
+            this.commit({ ...model, nodes });
+        };
+        this.onWindowPointerUpForResize = () => {
+            this.resize = null;
+            window.removeEventListener('pointermove', this.onWindowPointerMoveForResize);
+            window.removeEventListener('pointerup', this.onWindowPointerUpForResize);
+            window.removeEventListener('pointercancel', this.onWindowPointerUpForResize);
+        };
+        this.onWindowPointerMoveForLink = (ev) => {
+            const st = this.linkDrag();
+            if (!st)
+                return;
+            const to = this.canvasPointFromClient(ev.clientX, ev.clientY);
+            this.linkDrag.set({ ...st, to });
+            const model = this.model();
+            const node = findNode(model, st.sourceNodeId);
+            const port = node ? findPort(node, st.sourcePortId)?.port : undefined;
+            if (node && port) {
+                this.linkDragMove.emit({ sourceNode: node, sourcePort: port, point: to, event: ev });
+            }
+            const hover = this.pickInboundPortAtPoint(model, to, st.sourceNodeId);
+            this.linkHoverTarget.set(hover ? { nodeId: hover.node.id, portId: hover.port.id } : null);
+        };
+        this.onWindowPointerUpForLink = (ev) => {
+            const st = this.linkDrag();
+            this.linkDrag.set(null);
+            this.linkHoverTarget.set(null);
+            window.removeEventListener('pointermove', this.onWindowPointerMoveForLink);
+            window.removeEventListener('pointerup', this.onWindowPointerUpForLink);
+            window.removeEventListener('pointercancel', this.onWindowPointerUpForLink);
+            if (!st)
+                return;
+            const model = this.model();
+            const sourceNode = findNode(model, st.sourceNodeId);
+            const sourcePort = sourceNode ? findPort(sourceNode, st.sourcePortId)?.port : undefined;
+            if (!sourceNode || !sourcePort)
+                return;
+            const target = this.pickInboundPortAtPoint(model, st.to, sourceNode.id);
+            if (!target) {
+                this.linkDragEnd.emit({ sourceNode, sourcePort, cancelled: true, event: ev });
+                return;
+            }
+            const request = {
+                model,
+                sourceNodeId: st.sourceNodeId,
+                sourcePortId: st.sourcePortId,
+                targetNodeId: target.node.id,
+                targetPortId: target.port.id,
+            };
+            if (!this.evaluateConnect(request)) {
+                this.connectionRejected.emit({ reason: 'canConnect returned false', request, event: ev });
+                this.linkDragEnd.emit({ sourceNode, sourcePort, cancelled: true, event: ev });
+                return;
+            }
+            const connector = {
+                id: createWorkflowConnectorId(),
+                sourceNodeId: st.sourceNodeId,
+                sourcePortId: st.sourcePortId,
+                targetNodeId: target.node.id,
+                targetPortId: target.port.id,
+                data: {},
+                color: sourceNode.color,
+            };
+            const next = {
+                nodes: [...model.nodes],
+                connectors: [...model.connectors, connector],
+            };
+            this.commit(next);
+            this.connectionCreated.emit({ connector, model: next });
+            this.setActivation({ kind: 'connector', id: connector.id });
+            this.linkDragEnd.emit({ sourceNode, sourcePort, cancelled: false, event: ev });
+        };
+        afterNextRender(() => this.attachWrapperDropTargetsWithRetry());
+        effect(() => this.syncWrapperBackgroundStyle());
+        effect(() => {
+            this.zoomChange.emit(this.panZoomLevel());
+        });
+        this.destroyRef.onDestroy(() => this.detachWindowListeners());
+    }
+    zoomIn() {
+        this.panViewRef()?.zoomIn();
+    }
+    zoomOut() {
+        this.panViewRef()?.zoomOut();
+    }
+    zoomReset() {
+        this.panViewRef()?.resetPosition();
+    }
+    getZoomLevel() {
+        return this.panZoomLevel();
+    }
+    //#region ---- Readonly helpers ----
+    isNodeReadonly(node) {
+        return this.readonly() || node.readonly === true;
+    }
+    isConnectorReadonly(c) {
+        return this.readonly() || c.readonly === true;
+    }
+    //#endregion
+    //#region ---- Activation ----
+    isNodeActive(nodeId) {
+        return this.selectedNodeIds().has(nodeId);
+    }
+    isNodeHighlighted(nodeId) {
+        return this.highlightedNodeIds().includes(nodeId);
+    }
+    isConnectorActive(id) {
+        return this.selectedConnectorIds().has(id);
+    }
+    isPortActive(nodeId, portId) {
+        const a = this.activation();
+        return a?.kind === 'port' && a.nodeId === nodeId && a.id === portId;
+    }
+    isPortLinkHoverTarget(nodeId, portId) {
+        if (!this.linkDrag())
+            return false;
+        const h = this.linkHoverTarget();
+        return h !== null && h.nodeId === nodeId && h.portId === portId;
+    }
+    setActivation(next) {
+        this.activation.set(next);
+        this.activationChange.emit(next);
+    }
+    clearSelections() {
+        this.selectedNodeIds.set(new Set());
+        this.selectedConnectorIds.set(new Set());
+    }
+    //#endregion
+    //#region ---- Model commit ----
+    commit(next) {
+        this.modelChange.emit(next);
+    }
+    /**
+     * Auto-arranges nodes into a layered layout and commits the result.
+     *
+     * Honors layout options such as `direction` (`'horizontal'` / `'vertical'`),
+     * `alignment`, `origin`, `nodeIds` (subset arrange), and `reduceCrossings`.
+     * When `gridSize` is omitted the designer's own `gridSize` input is used.
+     */
+    arrangeNicely(options) {
+        if (this.readonly()) {
+            return;
+        }
+        this.commit(this.computeArrangedLayout(options));
+    }
+    /**
+     * Computes an arranged layout without committing it. Useful for previews,
+     * comparing the result before applying it, or rendering ghost positions.
+     */
+    computeArrangedLayout(options) {
+        return arrangeWorkflowDiagram(cloneDiagram(this.model()), {
+            gridSize: this.gridSize(),
+            ...options,
+        });
+    }
+    resolvePaletteItem(type) {
+        return this.paletteItems().find((i) => i.type === type);
+    }
+    /**
+     * Full drag payload merged with `paletteItems()` entry when the payload omits optional fields.
+     */
+    resolveDroppedPaletteItem(raw) {
+        const parsed = parsePaletteItemDragPayload(raw);
+        if (!parsed)
+            return null;
+        const base = this.resolvePaletteItem(parsed.type);
+        const item = { ...(base ?? {}), ...parsed };
+        if (typeof item.title !== 'string')
+            return null;
+        return item;
+    }
+    evaluateConnect(request) {
+        const fn = this.canConnect();
+        if (fn)
+            return fn(request);
+        return defaultCanConnectRequest(request);
+    }
+    //#endregion
+    //#region ---- Canvas / surface ----
+    onSurfacePointerDown(event) {
+        if (!this.isBackgroundInteractionTarget(event.target))
+            return;
+        this.designerPointerDown.emit(event);
+    }
+    onSurfaceClick(event) {
+        if (!this.isBackgroundInteractionTarget(event.target))
+            return;
+        this.clearSelections();
+        this.setActivation({ kind: 'canvas', id: 'canvas' });
+        this.designerClick.emit(event);
+    }
+    onSurfaceDoubleClick(event) {
+        if (!this.isBackgroundInteractionTarget(event.target))
+            return;
+        this.designerDoubleClick.emit(event);
+    }
+    isBackgroundInteractionTarget(target) {
+        if (!target)
+            return false;
+        if (target.closest('.axp-workflow-designer__node'))
+            return false;
+        if (target.closest('.axp-workflow-designer__connector-actions'))
+            return false;
+        if (target.closest('.axp-workflow-designer__port-cluster'))
+            return false;
+        if (target.closest('path.axp-workflow-designer__edge-hit'))
+            return false;
+        if (target.closest('ax-button'))
+            return false;
+        return true;
+    }
+    canvasPointFromClient(clientX, clientY) {
+        const surface = this.surfaceRef().nativeElement;
+        const wrapper = surface.closest('.ax-pan-view-wrapper');
+        const basisRect = (wrapper ?? surface).getBoundingClientRect();
+        const localX = clientX - basisRect.left;
+        const localY = clientY - basisRect.top;
+        const computed = getComputedStyle(surface);
+        const transform = computed.transform;
+        if (!transform || transform === 'none') {
+            return this.surfacePointToModel({ x: localX, y: localY });
+        }
+        const matrix = new DOMMatrixReadOnly(transform);
+        const originParts = computed.transformOrigin.split(' ');
+        const originX = Number.parseFloat(originParts[0] ?? '0') || 0;
+        const originY = Number.parseFloat(originParts[1] ?? '0') || 0;
+        // CSS transform is applied around transform-origin, so include origin translation in matrix inversion.
+        const withOrigin = new DOMMatrixReadOnly()
+            .translate(originX, originY)
+            .multiply(matrix)
+            .translate(-originX, -originY);
+        const point = new DOMPoint(localX, localY).matrixTransform(withOrigin.inverse());
+        return this.surfacePointToModel({ x: point.x, y: point.y });
+    }
+    //#endregion
+    //#region ---- Drag / drop (palette) ----
+    onCanvasDragOver(event) {
+        if (this.readonly())
+            return;
+        event.preventDefault();
+        if (event.dataTransfer)
+            event.dataTransfer.dropEffect = 'copy';
+    }
+    onCanvasDrop(event) {
+        if (this.readonly())
+            return;
+        event.preventDefault();
+        event.stopPropagation();
+        const raw = event.dataTransfer?.getData(AXP_WORKFLOW_PALETTE_MIME);
+        const item = this.resolveDroppedPaletteItem(raw);
+        if (!item)
+            return;
+        const pt = this.canvasPointFromClient(event.clientX, event.clientY);
+        const node = createNodeFromPaletteItem(item, this.applySnapToPointForNewNode(item, pt));
+        const model = this.model();
+        const next = {
+            nodes: [...model.nodes, node],
+            connectors: [...model.connectors],
+        };
+        this.commit(next);
+        this.setActivation({ kind: 'node', id: node.id });
+    }
+    applySnapToPointForNewNode(item, pt) {
+        const nodeSnap = item.snapToGrid;
+        const useSnap = nodeSnap ?? this.snapToGrid();
+        const g = this.gridSize();
+        if (!useSnap || g <= 0)
+            return pt;
+        return snapPoint(pt, g);
+    }
+    applySnapForNode(node, pt) {
+        const useSnap = node.snapToGrid ?? this.snapToGrid();
+        const g = this.gridSize();
+        if (!useSnap || g <= 0)
+            return pt;
+        return snapPoint(pt, g);
+    }
+    //#endregion
+    //#region ---- Wrapper drop bridge ----
+    attachWrapperDropTargetsWithRetry() {
+        this.clearWrapperAttachRetry();
+        this.wrapperAttachAttempt = 0;
+        const tryAttach = () => {
+            const attached = this.attachWrapperDropTargets();
+            if (attached) {
+                return;
+            }
+            this.wrapperAttachAttempt += 1;
+            if (this.wrapperAttachAttempt >= 20) {
+                return;
+            }
+            this.wrapperAttachRetryHandle = setTimeout(tryAttach, 50);
+        };
+        tryAttach();
+    }
+    /**
+     * Binds drag/drop to pan-view wrapper so users can drop while panning far away
+     * from current finite surface bounds.
+     */
+    attachWrapperDropTargets() {
+        const surface = this.surfaceRef().nativeElement;
+        const wrapper = surface.closest('.ax-pan-view-wrapper');
+        if (!wrapper) {
+            return false;
+        }
+        this.detachWrapperDropTargets();
+        this.wrapperElement.set(wrapper);
+        this.wrapperDragoverListener = (event) => {
+            const target = event.target;
+            if (target?.closest('.axp-workflow-designer__surface')) {
+                return;
+            }
+            this.onCanvasDragOver(event);
+        };
+        this.wrapperDropListener = (event) => {
+            const target = event.target;
+            if (target?.closest('.axp-workflow-designer__surface')) {
+                return;
+            }
+            this.onCanvasDrop(event);
+        };
+        wrapper.addEventListener('dragover', this.wrapperDragoverListener);
+        wrapper.addEventListener('drop', this.wrapperDropListener);
+        this.syncWrapperBackgroundStyle();
+        return true;
+    }
+    detachWrapperDropTargets() {
+        const surface = this.surfaceRef().nativeElement;
+        const wrapper = surface.closest('.ax-pan-view-wrapper');
+        if (!wrapper) {
+            this.wrapperElement.set(null);
+            this.wrapperDragoverListener = null;
+            this.wrapperDropListener = null;
+            return;
+        }
+        if (this.wrapperDragoverListener) {
+            wrapper.removeEventListener('dragover', this.wrapperDragoverListener);
+            this.wrapperDragoverListener = null;
+        }
+        if (this.wrapperDropListener) {
+            wrapper.removeEventListener('drop', this.wrapperDropListener);
+            this.wrapperDropListener = null;
+        }
+        this.wrapperElement.set(null);
+    }
+    clearWrapperAttachRetry() {
+        if (this.wrapperAttachRetryHandle != null) {
+            clearTimeout(this.wrapperAttachRetryHandle);
+            this.wrapperAttachRetryHandle = null;
+        }
+    }
+    //#endregion
+    //#region ---- Keyboard ----
+    onWindowKeydown(ev) {
+        if (this.readonly())
+            return;
+        const target = ev.target;
+        if (target?.closest('input,textarea,select,[contenteditable="true"]'))
+            return;
+        if (ev.key === 'Escape') {
+            ev.preventDefault();
+            this.cancelLinkDrag(ev);
+            this.clearSelections();
+            this.setActivation(null);
+            return;
+        }
+        if (ev.key !== 'Delete' && ev.key !== 'Backspace')
+            return;
+        ev.preventDefault();
+        const selectedConnectorIds = this.selectedConnectorIds();
+        const selectedNodeIds = this.selectedNodeIds();
+        const model = this.model();
+        if (selectedConnectorIds.size > 0 || selectedNodeIds.size > 0) {
+            const nodes = model.nodes.filter((n) => !selectedNodeIds.has(n.id));
+            const connectors = model.connectors.filter((c) => !selectedConnectorIds.has(c.id) &&
+                !selectedNodeIds.has(c.sourceNodeId) &&
+                !selectedNodeIds.has(c.targetNodeId));
+            this.commit({ ...model, nodes, connectors });
+            this.clearSelections();
+            this.setActivation(null);
+            return;
+        }
+        const a = this.activation();
+        if (!a || a.kind === 'canvas')
+            return;
+        if (a.kind === 'connector') {
+            const c = findConnector(model, a.id);
+            if (c && !this.isConnectorReadonly(c)) {
+                const connectors = model.connectors.filter((x) => x.id !== c.id);
+                this.commit({ ...model, connectors });
+                this.setActivation(null);
+            }
+            return;
+        }
+        const nodeId = a.kind === 'node' ? a.id : a.nodeId;
+        if (!nodeId)
+            return;
+        const node = findNode(model, nodeId);
+        if (!node || this.isNodeReadonly(node))
+            return;
+        const nodes = model.nodes.filter((n) => n.id !== nodeId);
+        const connectors = model.connectors.filter((c) => c.sourceNodeId !== nodeId && c.targetNodeId !== nodeId);
+        this.commit({ ...model, nodes, connectors });
+        this.setActivation(null);
+    }
+    cancelLinkDrag(ev) {
+        const st = this.linkDrag();
+        if (!st)
+            return;
+        this.linkDrag.set(null);
+        this.linkHoverTarget.set(null);
+        window.removeEventListener('pointermove', this.onWindowPointerMoveForLink);
+        window.removeEventListener('pointerup', this.onWindowPointerUpForLink);
+        window.removeEventListener('pointercancel', this.onWindowPointerUpForLink);
+        const model = this.model();
+        const sourceNode = findNode(model, st.sourceNodeId);
+        const sourcePort = sourceNode ? findPort(sourceNode, st.sourcePortId)?.port : undefined;
+        if (sourceNode && sourcePort) {
+            this.linkDragEnd.emit({ sourceNode, sourcePort, cancelled: true, event: ev });
+        }
+    }
+    //#endregion
+    //#region ---- Node chrome ----
+    shapeClass(shape) {
+        return `axp-workflow-designer__node-shape--${shape}`;
+    }
+    semanticSurfaceClass(color) {
+        return color ? `axp-${color}-surface` : '';
+    }
+    semanticBorderClass(color) {
+        return color ? `axp-${color}-border` : '';
+    }
+    nodeShapeClasses(node) {
+        return ['axp-workflow-designer__node-shape', this.shapeClass(node.shape), this.semanticSurfaceClass(node.color), this.semanticBorderClass(node.borderColor)]
+            .filter(Boolean)
+            .join(' ');
+    }
+    connectorEdgeClasses(c) {
+        const parts = [
+            'axp-workflow-designer__edge',
+            this.semanticSurfaceClass(c.color),
+            this.semanticBorderClass(c.borderColor),
+            this.isConnectorActive(c.id) ? 'axp-workflow-designer__edge--active' : '',
+        ];
+        return parts.filter(Boolean).join(' ');
+    }
+    onNodePointerDown(node, event) {
+        if (this.isNodeReadonly(node))
+            return;
+        if (event.button !== 0)
+            return;
+        this.nodePointerDown.emit({ node, event });
+    }
+    onNodeClick(node, event) {
+        if (this.suppressNextNodeClick) {
+            this.suppressNextNodeClick = false;
+            event.stopPropagation();
+            return;
+        }
+        event.stopPropagation();
+        const append = event.ctrlKey || event.metaKey;
+        if (append) {
+            const next = new Set(this.selectedNodeIds());
+            if (next.has(node.id))
+                next.delete(node.id);
+            else
+                next.add(node.id);
+            this.selectedNodeIds.set(next);
+            this.selectedConnectorIds.set(new Set());
+        }
+        else {
+            this.selectedNodeIds.set(new Set([node.id]));
+            this.selectedConnectorIds.set(new Set());
+        }
+        this.setActivation({ kind: 'node', id: node.id });
+        this.nodeClick.emit({ node, event: event });
+    }
+    onNodeDoubleClick(node, event) {
+        event.stopPropagation();
+        this.nodeDoubleClick.emit({ node, event });
+    }
+    onNodeContextMenu(node, event) {
+        if (this.isNodeReadonly(node)) {
+            return;
+        }
+        event.preventDefault();
+        event.stopPropagation();
+        this.selectedNodeIds.set(new Set([node.id]));
+        this.selectedConnectorIds.set(new Set());
+        this.setActivation({ kind: 'node', id: node.id });
+        this.nodeContextMenu.emit({ node, event });
+    }
+    onNodeBodyPointerDown(node, event) {
+        if (this.isNodeReadonly(node))
+            return;
+        if (event.button !== 0)
+            return;
+        if (event.target.closest('.axp-workflow-designer__port-cluster'))
+            return;
+        if (event.target.closest('.axp-workflow-designer__resize'))
+            return;
+        // Ctrl/Cmd click is reserved for multi-select toggling in click handler; do not start drag here.
+        if (event.ctrlKey || event.metaKey)
+            return;
+        event.stopPropagation();
+        const selected = this.selectedNodeIds();
+        const moveIds = selected.has(node.id) && selected.size > 0 ? [...selected] : [node.id];
+        if (!selected.has(node.id) || selected.size === 0) {
+            this.selectedNodeIds.set(new Set([node.id]));
+            this.selectedConnectorIds.set(new Set());
+        }
+        this.setActivation({ kind: 'node', id: node.id });
+        const p = this.canvasPointFromClient(event.clientX, event.clientY);
+        const model = this.model();
+        const origins = {};
+        for (const moveId of moveIds) {
+            const n = findNode(model, moveId);
+            if (n)
+                origins[moveId] = { ...n.position };
+        }
+        this.nodeMove = {
+            nodeIds: moveIds,
+            start: p,
+            origins,
+            moved: false,
+        };
+        this.nodeDragStart.emit({ node, event });
+        window.addEventListener('pointermove', this.onWindowPointerMoveForNode);
+        window.addEventListener('pointerup', this.onWindowPointerUpForNode, { once: false });
+        window.addEventListener('pointercancel', this.onWindowPointerUpForNode, { once: false });
+        event.target.setPointerCapture?.(event.pointerId);
+    }
+    //#endregion
+    //#region ---- Resize ----
+    onResizePointerDown(node, handle, event) {
+        if (this.isNodeReadonly(node))
+            return;
+        if (event.button !== 0)
+            return;
+        event.stopPropagation();
+        this.resize = {
+            nodeId: node.id,
+            handle,
+            startPointer: this.canvasPointFromClient(event.clientX, event.clientY),
+            startPosition: { ...node.position },
+            startSize: { ...node.size },
+            aspect: node.size.width / Math.max(1, node.size.height),
+        };
+        window.addEventListener('pointermove', this.onWindowPointerMoveForResize);
+        window.addEventListener('pointerup', this.onWindowPointerUpForResize);
+        window.addEventListener('pointercancel', this.onWindowPointerUpForResize);
+    }
+    //#endregion
+    //#region ---- Ports & linking ----
+    onPortPointerDown(node, port, event) {
+        if (this.isNodeReadonly(node))
+            return;
+        if (port.readonly)
+            return;
+        if (event.button !== 0)
+            return;
+        event.stopPropagation();
+        this.portPointerDown.emit({ node, port, event });
+        this.setActivation({ kind: 'port', id: port.id, nodeId: node.id });
+        if (port.kind === 'outbound' && !port.disabled) {
+            this.linkHoverTarget.set(null);
+            const from = portCanvasPosition(node, port);
+            this.linkDrag.set({
+                sourceNodeId: node.id,
+                sourcePortId: port.id,
+                from,
+                to: from,
+            });
+            this.linkDragStart.emit({ sourceNode: node, sourcePort: port, event });
+            window.addEventListener('pointermove', this.onWindowPointerMoveForLink);
+            window.addEventListener('pointerup', this.onWindowPointerUpForLink);
+            window.addEventListener('pointercancel', this.onWindowPointerUpForLink);
+        }
+    }
+    pickInboundPortAtPoint(model, point, excludeSourceNodeId) {
+        let best = null;
+        const hitR = 18;
+        for (const node of model.nodes) {
+            if (node.id === excludeSourceNodeId)
+                continue;
+            if (this.isNodeReadonly(node))
+                continue;
+            for (const port of node.inboundPorts) {
+                if (port.disabled || port.readonly)
+                    continue;
+                const c = portCanvasPosition(node, port);
+                const d = Math.hypot(c.x - point.x, c.y - point.y);
+                if (d <= hitR && (!best || d < best.d))
+                    best = { node, port, d };
+            }
+        }
+        return best ? { node: best.node, port: best.port } : null;
+    }
+    //#endregion
+    //#region ---- Connectors UI ----
+    connectorPathD(c) {
+        const model = this.model();
+        const sn = findNode(model, c.sourceNodeId);
+        const tn = findNode(model, c.targetNodeId);
+        if (!sn || !tn)
+            return '';
+        const sp = findPort(sn, c.sourcePortId)?.port;
+        const tp = findPort(tn, c.targetPortId)?.port;
+        if (!sp || !tp)
+            return '';
+        const from = this.modelPointToSurface(portCanvasPosition(sn, sp));
+        const to = this.trimmedConnectorTarget(from, this.modelPointToSurface(portCanvasPosition(tn, tp)));
+        return connectorPath(from, to, this.connectionPreviewStyle(), sp.side, {
+            targetSide: tp.side,
+            obstacles: this.collectObstaclesInSurface(),
+        });
+    }
+    connectorMidpoint(c) {
+        const model = this.model();
+        const sn = findNode(model, c.sourceNodeId);
+        const tn = findNode(model, c.targetNodeId);
+        if (!sn || !tn)
+            return { x: 0, y: 0 };
+        const sp = findPort(sn, c.sourcePortId)?.port;
+        const tp = findPort(tn, c.targetPortId)?.port;
+        if (!sp || !tp)
+            return { x: 0, y: 0 };
+        const a = this.modelPointToSurface(portCanvasPosition(sn, sp));
+        const b = this.modelPointToSurface(portCanvasPosition(tn, tp));
+        return { x: (a.x + b.x) * 0.5, y: (a.y + b.y) * 0.5 };
+    }
+    onConnectorClick(c, event) {
+        event.stopPropagation();
+        event.preventDefault();
+        const append = event.ctrlKey || event.metaKey;
+        if (append) {
+            const next = new Set(this.selectedConnectorIds());
+            if (next.has(c.id))
+                next.delete(c.id);
+            else
+                next.add(c.id);
+            this.selectedConnectorIds.set(next);
+            this.selectedNodeIds.set(new Set());
+        }
+        else {
+            this.selectedConnectorIds.set(new Set([c.id]));
+            this.selectedNodeIds.set(new Set());
+        }
+        this.setActivation({ kind: 'connector', id: c.id });
+        this.connectorClick.emit({ connector: c, event });
+    }
+    onConnectorDoubleClick(c, event) {
+        event.stopPropagation();
+        event.preventDefault();
+        this.connectorDoubleClick.emit({ connector: c, event });
+    }
+    removeConnector(c) {
+        if (this.isConnectorReadonly(c))
+            return;
+        const model = this.model();
+        const connectors = model.connectors.filter((x) => x.id !== c.id);
+        this.commit({ ...model, connectors });
+        this.setActivation(null);
+    }
+    previewPath() {
+        const st = this.linkDrag();
+        if (!st)
+            return '';
+        const model = this.model();
+        const sn = findNode(model, st.sourceNodeId);
+        const sp = sn ? findPort(sn, st.sourcePortId)?.port : undefined;
+        if (!sn || !sp)
+            return '';
+        const from = this.modelPointToSurface(st.from);
+        const to = this.modelPointToSurface(st.to);
+        const hover = this.linkHoverTarget();
+        const hoverNode = hover ? findNode(model, hover.nodeId) : undefined;
+        const hoverPort = hover && hoverNode ? findPort(hoverNode, hover.portId)?.port : undefined;
+        return connectorPath(from, this.trimmedConnectorTarget(from, to), this.connectionPreviewStyle(), sp.side, {
+            targetSide: hoverPort?.side,
+            obstacles: this.collectObstaclesInSurface(),
+        });
+    }
+    //#endregion
+    //#region ---- Template context ----
+    templateContext(node) {
+        return { $implicit: node, node };
+    }
+    portClusterStyle(node, port) {
+        const local = portAnchorOnNode(node, port);
+        const w = Math.max(1, node.size.width);
+        const h = Math.max(1, node.size.height);
+        return {
+            position: 'absolute',
+            left: `${(local.x / w) * 100}%`,
+            top: `${(local.y / h) * 100}%`,
+            'z-index': '3',
+        };
+    }
+    portLabelText(port) {
+        return (port.label ?? port.key ?? '').trim();
+    }
+    portLabelX(node, port) {
+        return this.portLabelCanvasPoint(node, port).x;
+    }
+    portLabelY(node, port) {
+        return this.portLabelCanvasPoint(node, port).y;
+    }
+    portLabelAnchor(node, port) {
+        const centerX = this.modelPointToSurface({ x: node.position.x + node.size.width * 0.5, y: node.position.y }).x;
+        const anchor = this.modelPointToSurface(portCanvasPosition(node, port));
+        const dx = anchor.x - centerX;
+        if (Math.abs(dx) < 6)
+            return 'middle';
+        return dx < 0 ? 'end' : 'start';
+    }
+    nodeSurfaceLeft(node) {
+        return node.position.x + this.canvasViewport().offsetX;
+    }
+    nodeSurfaceTop(node) {
+        return node.position.y + this.canvasViewport().offsetY;
+    }
+    trimmedConnectorTarget(from, to) {
+        const dx = to.x - from.x;
+        const dy = to.y - from.y;
+        const len = Math.hypot(dx, dy);
+        if (len < 0.001)
+            return to;
+        // Keep arrowhead just outside the 14px port without creating a visible gap.
+        const trim = 7;
+        return {
+            x: to.x - (dx / len) * trim,
+            y: to.y - (dy / len) * trim,
+        };
+    }
+    portLabelCanvasPoint(node, port) {
+        const anchor = this.modelPointToSurface(portCanvasPosition(node, port));
+        const center = {
+            x: node.position.x + node.size.width * 0.5 + this.canvasViewport().offsetX,
+            y: node.position.y + node.size.height * 0.5 + this.canvasViewport().offsetY,
+        };
+        const vx = anchor.x - center.x;
+        const vy = anchor.y - center.y;
+        const len = Math.hypot(vx, vy);
+        if (len < 0.001)
+            return anchor;
+        const outward = 18;
+        return {
+            x: anchor.x + (vx / len) * outward,
+            y: anchor.y + (vy / len) * outward,
+        };
+    }
+    //#endregion
+    //#region ---- Canvas mapping ----
+    modelPointToSurface(point) {
+        const viewport = this.canvasViewport();
+        return {
+            x: point.x + viewport.offsetX,
+            y: point.y + viewport.offsetY,
+        };
+    }
+    surfacePointToModel(point) {
+        const viewport = this.canvasViewport();
+        return {
+            x: point.x - viewport.offsetX,
+            y: point.y - viewport.offsetY,
+        };
+    }
+    /**
+     * Returns node bounding boxes in surface coordinates.
+     *
+     * All nodes are returned so the router can route AROUND every node, including
+     * the source and target of a connector. The router itself drops obstacles that
+     * already contain the stub-out point so the connector can still exit/enter its port.
+     */
+    collectObstaclesInSurface() {
+        const viewport = this.canvasViewport();
+        const obstacles = [];
+        for (const node of this.model().nodes) {
+            obstacles.push({
+                position: { x: node.position.x + viewport.offsetX, y: node.position.y + viewport.offsetY },
+                size: { width: node.size.width, height: node.size.height },
+            });
+        }
+        return obstacles;
+    }
+    //#endregion
+    //#region ---- Wrapper visuals ----
+    syncWrapperBackgroundStyle() {
+        const wrapper = this.wrapperElement();
+        if (!wrapper) {
+            return;
+        }
+        const gridStyle = this.gridStyle();
+        wrapper.style.backgroundColor = 'var(--ax-sys-color-lightest-surface)';
+        wrapper.style.backgroundImage = String(gridStyle['background-image'] ?? '');
+        wrapper.style.backgroundSize = String(gridStyle['background-size'] ?? '');
+        wrapper.style.borderRadius = '10px';
+    }
+    //#endregion
+    detachWindowListeners() {
+        this.clearWrapperAttachRetry();
+        this.detachWrapperDropTargets();
+        this.linkHoverTarget.set(null);
+        window.removeEventListener('pointermove', this.onWindowPointerMoveForNode);
+        window.removeEventListener('pointerup', this.onWindowPointerUpForNode);
+        window.removeEventListener('pointercancel', this.onWindowPointerUpForNode);
+        window.removeEventListener('pointermove', this.onWindowPointerMoveForResize);
+        window.removeEventListener('pointerup', this.onWindowPointerUpForResize);
+        window.removeEventListener('pointercancel', this.onWindowPointerUpForResize);
+        window.removeEventListener('pointermove', this.onWindowPointerMoveForLink);
+        window.removeEventListener('pointerup', this.onWindowPointerUpForLink);
+        window.removeEventListener('pointercancel', this.onWindowPointerUpForLink);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPWorkflowDesignerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.0.8", type: AXPWorkflowDesignerComponent, isStandalone: true, selector: "axp-workflow-designer", inputs: { model: { classPropertyName: "model", publicName: "model", isSignal: true, isRequired: true, transformFunction: null }, readonly: { classPropertyName: "readonly", publicName: "readonly", isSignal: true, isRequired: false, transformFunction: null }, highlightedNodeIds: { classPropertyName: "highlightedNodeIds", publicName: "highlightedNodeIds", isSignal: true, isRequired: false, transformFunction: null }, gridSize: { classPropertyName: "gridSize", publicName: "gridSize", isSignal: true, isRequired: false, transformFunction: null }, snapToGrid: { classPropertyName: "snapToGrid", publicName: "snapToGrid", isSignal: true, isRequired: false, transformFunction: null }, connectionPreviewStyle: { classPropertyName: "connectionPreviewStyle", publicName: "connectionPreviewStyle", isSignal: true, isRequired: false, transformFunction: null }, backgroundPattern: { classPropertyName: "backgroundPattern", publicName: "backgroundPattern", isSignal: true, isRequired: false, transformFunction: null }, canConnect: { classPropertyName: "canConnect", publicName: "canConnect", isSignal: true, isRequired: false, transformFunction: null }, paletteItems: { classPropertyName: "paletteItems", publicName: "paletteItems", isSignal: true, isRequired: false, transformFunction: null }, showPortLabels: { classPropertyName: "showPortLabels", publicName: "showPortLabels", isSignal: true, isRequired: false, transformFunction: null }, nodeBodyTemplate: { classPropertyName: "nodeBodyTemplate", publicName: "nodeBodyTemplate", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { modelChange: "modelChange", zoomChange: "zoomChange", designerPointerDown: "designerPointerDown", designerClick: "designerClick", designerDoubleClick: "designerDoubleClick", nodePointerDown: "nodePointerDown", nodeClick: "nodeClick", nodeDoubleClick: "nodeDoubleClick", nodeContextMenu: "nodeContextMenu", nodeDragStart: "nodeDragStart", nodeDragEnd: "nodeDragEnd", portPointerDown: "portPointerDown", linkDragStart: "linkDragStart", linkDragMove: "linkDragMove", linkDragEnd: "linkDragEnd", connectorClick: "connectorClick", connectorDoubleClick: "connectorDoubleClick", connectionCreated: "connectionCreated", connectionRejected: "connectionRejected", activationChange: "activationChange" }, host: { listeners: { "window:keydown": "onWindowKeydown($event)" }, classAttribute: "axp-workflow-designer-host" }, viewQueries: [{ propertyName: "surfaceRef", first: true, predicate: ["surface"], descendants: true, isSignal: true }, { propertyName: "panViewRef", first: true, predicate: AXPanViewDirective, descendants: true, isSignal: true }], ngImport: i0, template: "<div class=\"axp-workflow-designer\" [ngStyle]=\"gridStyle()\">\n  <div\n    #surface\n    class=\"axp-workflow-designer__surface\"\n    axPanView\n    [(panX)]=\"panX\"\n    [(panY)]=\"panY\"\n    [(zoom)]=\"panZoomLevel\"\n    [maxZoom]=\"10000\"\n    [freeMode]=\"true\"\n    [fitContent]=\"true\"\n    wrapperClasses=\"h\"\n    [ngStyle]=\"surfaceStyle()\"\n    (pointerdown)=\"onSurfacePointerDown($event)\"\n    (click)=\"onSurfaceClick($event)\"\n    (dblclick)=\"onSurfaceDoubleClick($event)\"\n    (dragover)=\"onCanvasDragOver($event)\"\n    (drop)=\"onCanvasDrop($event)\"\n  >\n    <svg\n      class=\"axp-workflow-designer__svg\"\n      width=\"100%\"\n      height=\"100%\"\n      preserveAspectRatio=\"xMinYMin meet\"\n    >\n      <defs>\n        <marker\n          [attr.id]=\"svgMarkerId\"\n          markerWidth=\"6\"\n          markerHeight=\"6\"\n          refX=\"3.9\"\n          refY=\"3\"\n          orient=\"auto\"\n        >\n          <path\n            d=\"M0,0 L4,3 L0,6 Q1.5,3 0,0 Z\"\n            class=\"axp-workflow-designer__arrow-head\"\n          ></path>\n        </marker>\n      </defs>\n      @for (c of model().connectors; track c.id) {\n        <path\n          class=\"axp-workflow-designer__edge-hit\"\n          [attr.d]=\"connectorPathD(c)\"\n          fill=\"none\"\n          stroke=\"transparent\"\n          stroke-width=\"16\"\n          pointer-events=\"stroke\"\n          (click)=\"onConnectorClick(c, $event)\"\n          (dblclick)=\"onConnectorDoubleClick(c, $event)\"\n        />\n        <path\n          [class]=\"connectorEdgeClasses(c)\"\n          [attr.d]=\"connectorPathD(c)\"\n          fill=\"none\"\n          [attr.marker-end]=\"'url(#' + svgMarkerId + ')'\"\n        />\n      }\n      @if (linkDrag()) {\n        <path\n          class=\"axp-workflow-designer__edge-preview\"\n          [attr.d]=\"previewPath()\"\n          fill=\"none\"\n        />\n      }\n      @if (showPortLabels()) {\n        @for (node of model().nodes; track node.id) {\n          @for (port of node.inboundPorts; track port.id) {\n            @if (portLabelText(port)) {\n              <text\n                class=\"axp-workflow-designer__port-label-svg\"\n                [attr.x]=\"portLabelX(node, port)\"\n                [attr.y]=\"portLabelY(node, port)\"\n                [attr.text-anchor]=\"portLabelAnchor(node, port)\"\n              >\n                {{ portLabelText(port) }}\n              </text>\n            }\n          }\n          @for (port of node.outboundPorts; track port.id) {\n            @if (portLabelText(port)) {\n              <text\n                class=\"axp-workflow-designer__port-label-svg\"\n                [attr.x]=\"portLabelX(node, port)\"\n                [attr.y]=\"portLabelY(node, port)\"\n                [attr.text-anchor]=\"portLabelAnchor(node, port)\"\n              >\n                {{ portLabelText(port) }}\n              </text>\n            }\n          }\n        }\n      }\n    </svg>\n\n    @for (c of model().connectors; track c.id) {\n      @if (isConnectorActive(c.id) && !isConnectorReadonly(c)) {\n        <div\n          class=\"axp-workflow-designer__connector-actions\"\n          [style.left.px]=\"connectorMidpoint(c).x - 16\"\n          [style.top.px]=\"connectorMidpoint(c).y - 16\"\n        >\n          <ax-button\n            look=\"blank\"\n            class=\"ax-sm axp-workflow-designer__icon-btn\"\n            (onClick)=\"removeConnector(c)\"\n          >\n            <ax-icon class=\"fa-solid fa-minus\"></ax-icon>\n          </ax-button>\n        </div>\n      }\n    }\n\n    @for (node of model().nodes; track node.id) {\n      <div\n        class=\"axp-workflow-designer__node\"\n        [class.axp-workflow-designer__node--active]=\"isNodeActive(node.id)\"\n        [class.axp-workflow-designer__node--highlighted]=\"\n          isNodeHighlighted(node.id)\n        \"\n        [style.left.px]=\"nodeSurfaceLeft(node)\"\n        [style.top.px]=\"nodeSurfaceTop(node)\"\n        [style.width.px]=\"node.size.width\"\n        [style.height.px]=\"node.size.height\"\n        (pointerdown)=\"onNodePointerDown(node, $event)\"\n        (click)=\"onNodeClick(node, $event)\"\n        (dblclick)=\"onNodeDoubleClick(node, $event)\"\n        (contextmenu)=\"onNodeContextMenu(node, $event)\"\n      >\n        <div [class]=\"nodeShapeClasses(node)\">\n          <div\n            class=\"axp-workflow-designer__node-body\"\n            (pointerdown)=\"onNodeBodyPointerDown(node, $event)\"\n          >\n            @if (nodeBodyTemplate(); as tpl) {\n              <ng-container\n                [ngTemplateOutlet]=\"tpl\"\n                [ngTemplateOutletContext]=\"templateContext(node)\"\n              />\n            } @else {\n              <div class=\"axp-workflow-designer__node-default\">\n                @if (node.icon) {\n                  <ax-icon\n                    class=\"axp-workflow-designer__node-default-icon\"\n                    [class]=\"node.icon\"\n                  ></ax-icon>\n                }\n                <span class=\"axp-workflow-designer__node-default-title\">{{\n                  node.title\n                }}</span>\n              </div>\n            }\n          </div>\n        </div>\n\n        @for (port of node.inboundPorts; track port.id) {\n          <div\n            class=\"axp-workflow-designer__port-cluster\"\n            [class.axp-workflow-designer__port-cluster--side-top]=\"\n              port.side === 'top'\n            \"\n            [class.axp-workflow-designer__port-cluster--side-right]=\"\n              port.side === 'right'\n            \"\n            [class.axp-workflow-designer__port-cluster--side-bottom]=\"\n              port.side === 'bottom'\n            \"\n            [class.axp-workflow-designer__port-cluster--side-left]=\"\n              port.side === 'left'\n            \"\n            [ngStyle]=\"portClusterStyle(node, port)\"\n          >\n            <button\n              type=\"button\"\n              class=\"axp-workflow-designer__port axp-workflow-designer__port--inbound\"\n              [class.axp-workflow-designer__port--active]=\"\n                isPortActive(node.id, port.id)\n              \"\n              [class.axp-workflow-designer__port--link-hover]=\"\n                isPortLinkHoverTarget(node.id, port.id)\n              \"\n              [class.axp-workflow-designer__port--disabled]=\"port.disabled\"\n              [disabled]=\"isNodeReadonly(node) || port.disabled === true\"\n              (pointerdown)=\"onPortPointerDown(node, port, $event)\"\n            ></button>\n          </div>\n        }\n        @for (port of node.outboundPorts; track port.id) {\n          <div\n            class=\"axp-workflow-designer__port-cluster\"\n            [class.axp-workflow-designer__port-cluster--side-top]=\"\n              port.side === 'top'\n            \"\n            [class.axp-workflow-designer__port-cluster--side-right]=\"\n              port.side === 'right'\n            \"\n            [class.axp-workflow-designer__port-cluster--side-bottom]=\"\n              port.side === 'bottom'\n            \"\n            [class.axp-workflow-designer__port-cluster--side-left]=\"\n              port.side === 'left'\n            \"\n            [ngStyle]=\"portClusterStyle(node, port)\"\n          >\n            <button\n              type=\"button\"\n              class=\"axp-workflow-designer__port axp-workflow-designer__port--outbound\"\n              [class.axp-workflow-designer__port--active]=\"\n                isPortActive(node.id, port.id)\n              \"\n              [class.axp-workflow-designer__port--disabled]=\"port.disabled\"\n              [disabled]=\"isNodeReadonly(node) || port.disabled === true\"\n              (pointerdown)=\"onPortPointerDown(node, port, $event)\"\n            ></button>\n          </div>\n        }\n\n        @if (isNodeActive(node.id) && !isNodeReadonly(node)) {\n          <span\n            class=\"axp-workflow-designer__resize axp-workflow-designer__resize--nw\"\n            (pointerdown)=\"onResizePointerDown(node, 'nw', $event)\"\n          ></span>\n          <span\n            class=\"axp-workflow-designer__resize axp-workflow-designer__resize--ne\"\n            (pointerdown)=\"onResizePointerDown(node, 'ne', $event)\"\n          ></span>\n          <span\n            class=\"axp-workflow-designer__resize axp-workflow-designer__resize--sw\"\n            (pointerdown)=\"onResizePointerDown(node, 'sw', $event)\"\n          ></span>\n          <span\n            class=\"axp-workflow-designer__resize axp-workflow-designer__resize--se\"\n            (pointerdown)=\"onResizePointerDown(node, 'se', $event)\"\n          ></span>\n        }\n      </div>\n    }\n  </div>\n</div>\n", styles: ["@layer properties;.axp-workflow-designer-host{box-sizing:border-box;display:block;height:100%;width:100%;min-height:360px;user-select:none;-webkit-user-select:none}.axp-workflow-designer{display:flex;height:100%;width:100%;min-height:inherit}.axp-workflow-designer .axp-workflow-designer__surface{position:relative;min-height:100%;min-width:100%;flex:auto;overflow:auto;border-radius:10px;user-select:none;-webkit-user-select:none}.axp-workflow-designer .axp-workflow-designer__surface::ng-deep .pan-view__wrapper{height:100%;width:100%}.axp-workflow-designer .axp-workflow-designer__svg{pointer-events:none;position:absolute;inset:0;height:100%;width:100%;z-index:1}.axp-workflow-designer .axp-workflow-designer__edge-hit{pointer-events:stroke;cursor:pointer}.axp-workflow-designer .axp-workflow-designer__edge{pointer-events:none;stroke:rgb(var(--ax-sys-color-neutral-500));stroke-width:2;transition:stroke .12s ease}.axp-workflow-designer .axp-workflow-designer__edge.primary-surface:not(.axp-workflow-designer__edge--active){stroke:rgb(var(--ax-sys-color-primary-500))}.axp-workflow-designer .axp-workflow-designer__edge.secondary-surface:not(.axp-workflow-designer__edge--active){stroke:rgb(var(--ax-sys-color-secondary-500))}.axp-workflow-designer .axp-workflow-designer__edge.success-surface:not(.axp-workflow-designer__edge--active){stroke:rgb(var(--ax-sys-color-success-500))}.axp-workflow-designer .axp-workflow-designer__edge.warning-surface:not(.axp-workflow-designer__edge--active){stroke:rgb(var(--ax-sys-color-warning-500))}.axp-workflow-designer .axp-workflow-designer__edge.danger-surface:not(.axp-workflow-designer__edge--active){stroke:rgb(var(--ax-sys-color-danger-500))}.axp-workflow-designer .axp-workflow-designer__edge--active{stroke:rgb(var(--ax-sys-color-primary-500));stroke-dasharray:2}.axp-workflow-designer .axp-workflow-designer__edge-preview{pointer-events:none;stroke:rgb(var(--ax-sys-color-primary-400));stroke-width:2;stroke-dasharray:6 4}.axp-workflow-designer .axp-workflow-designer__port-label-svg{fill:rgb(var(--ax-sys-color-on-surface));font-size:10px;font-weight:600;dominant-baseline:middle;pointer-events:none;paint-order:stroke;stroke:rgb(var(--ax-sys-color-surface));stroke-width:4px;stroke-linejoin:round}.axp-workflow-designer .axp-workflow-designer__arrow-head{fill:rgb(var(--ax-sys-color-neutral-500))}.axp-workflow-designer .axp-workflow-designer__connector-actions{position:absolute;display:flex;align-items:center;justify-content:center;z-index:4}.axp-workflow-designer .axp-workflow-designer__icon-btn{border-radius:999px;user-select:none;-webkit-user-select:none}.axp-workflow-designer .axp-workflow-designer__node{position:absolute;box-sizing:border-box;z-index:2;user-select:none;-webkit-user-select:none}.axp-workflow-designer .axp-workflow-designer__node.axp-workflow-designer__node--active .axp-workflow-designer__node-shape{border:2px dotted rgb(var(--ax-sys-color-primary-500))}.axp-workflow-designer .axp-workflow-designer__node.axp-workflow-designer__node--highlighted .axp-workflow-designer__node-shape{border:2px solid rgb(var(--ax-sys-color-primary-500));box-shadow:0 0 0 3px rgb(var(--ax-sys-color-primary-surface))}.axp-workflow-designer .axp-workflow-designer__node-shape{position:absolute;inset:0;box-sizing:border-box;overflow:visible;background:rgb(var(--ax-sys-color-surface))}.axp-workflow-designer .axp-workflow-designer__node-shape.axp-primary-surface{background:rgb(var(--ax-sys-color-primary-surface));color:rgb(var(--ax-sys-color-on-primary-surface))}.axp-workflow-designer .axp-workflow-designer__node-shape.axp-secondary-surface{background:rgb(var(--ax-sys-color-secondary-surface));color:rgb(var(--ax-sys-color-on-secondary-surface))}.axp-workflow-designer .axp-workflow-designer__node-shape.axp-success-surface{background:rgb(var(--ax-sys-color-success-surface));color:rgb(var(--ax-sys-color-on-success-surface))}.axp-workflow-designer .axp-workflow-designer__node-shape.axp-warning-surface{background:rgb(var(--ax-sys-color-warning-surface));color:rgb(var(--ax-sys-color-on-warning-surface))}.axp-workflow-designer .axp-workflow-designer__node-shape.axp-danger-surface{background:rgb(var(--ax-sys-color-danger-surface));color:rgb(var(--ax-sys-color-on-danger-surface))}.axp-workflow-designer .axp-workflow-designer__node-shape.axp-primary-border{border:2px solid rgb(var(--ax-sys-color-border-primary-surface))}.axp-workflow-designer .axp-workflow-designer__node-shape.axp-secondary-border{border:2px solid rgb(var(--ax-sys-color-border-secondary-surface))}.axp-workflow-designer .axp-workflow-designer__node-shape.axp-success-border{border:2px solid rgb(var(--ax-sys-color-border-success-surface))}.axp-workflow-designer .axp-workflow-designer__node-shape.axp-warning-border{border:2px solid rgb(var(--ax-sys-color-border-warning-surface))}.axp-workflow-designer .axp-workflow-designer__node-shape.axp-danger-border{border:2px solid rgb(var(--ax-sys-color-border-danger-surface))}.axp-workflow-designer .axp-workflow-designer__node-shape--rectangle{border-radius:4px}.axp-workflow-designer .axp-workflow-designer__node-shape--rounded-rectangle{border-radius:14px}.axp-workflow-designer .axp-workflow-designer__node-shape--circle,.axp-workflow-designer .axp-workflow-designer__node-shape--ellipse{border-radius:50%}.axp-workflow-designer .axp-workflow-designer__node-shape--diamond{border-radius:0;clip-path:polygon(50% 0%,100% 50%,50% 100%,0% 50%)}.axp-workflow-designer .axp-workflow-designer__node-body{position:absolute;inset:0;display:flex;cursor:grab;align-items:center;justify-content:center;padding:8px 12px;touch-action:none;user-select:none;-webkit-user-select:none}.axp-workflow-designer .axp-workflow-designer__node-default{display:flex;min-width:0px;align-items:center;gap:8px}.axp-workflow-designer .axp-workflow-designer__node-default-icon{flex-shrink:0}.axp-workflow-designer .axp-workflow-designer__node-default-title{overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-size:var(--text-sm, .875rem);line-height:var(--tw-leading, var(--text-sm--line-height, calc(1.25 / .875)));--tw-font-weight: var(--font-weight-semibold, 600);font-weight:var(--font-weight-semibold, 600)}.axp-workflow-designer .axp-workflow-designer__port-cluster{pointer-events:none;position:absolute;overflow:visible;width:0;height:0;transform:translate(-50%,-50%);z-index:3}.axp-workflow-designer .axp-workflow-designer__port{position:absolute;flex-shrink:0;cursor:crosshair;border-radius:calc(infinity * 1px);left:50%;top:50%;transform:translate(-50%,-50%);width:14px;height:14px;padding:0;border:1px solid rgb(var(--ax-sys-color-surface));touch-action:none;pointer-events:auto;transition:transform .12s ease}.axp-workflow-designer .axp-workflow-designer__port:disabled{opacity:.45;cursor:not-allowed}.axp-workflow-designer .axp-workflow-designer__port--inbound{background:rgb(var(--ax-sys-color-success-500))}.axp-workflow-designer .axp-workflow-designer__port--outbound{background:rgb(var(--ax-sys-color-primary-500))}.axp-workflow-designer .axp-workflow-designer__port--active{box-shadow:0 0 0 3px #3b82f659}.axp-workflow-designer .axp-workflow-designer__port--link-hover{border:1px solid rgb(var(--ax-sys-color-primary-500));transform:translate(-50%,-50%) scale(1.12)}.axp-workflow-designer .axp-workflow-designer__port--disabled{opacity:.45;cursor:not-allowed}.axp-workflow-designer .axp-workflow-designer__resize{position:absolute;border-radius:calc(infinity * 1px);width:7px;height:7px;background:rgb(var(--ax-sys-color-primary-500));border:1px solid rgb(var(--ax-sys-color-surface));z-index:4;touch-action:none;user-select:none;-webkit-user-select:none}.axp-workflow-designer .axp-workflow-designer__resize--nw{left:-6px;top:-6px;cursor:nwse-resize}.axp-workflow-designer .axp-workflow-designer__resize--ne{right:-6px;top:-6px;cursor:nesw-resize}.axp-workflow-designer .axp-workflow-designer__resize--sw{left:-6px;bottom:-6px;cursor:nesw-resize}.axp-workflow-designer .axp-workflow-designer__resize--se{right:-6px;bottom:-6px;cursor:nwse-resize}@property --tw-font-weight{syntax: \"*\"; inherits: false;}@layer properties{@supports ((-webkit-hyphens: none) and (not (margin-trim: inline))) or ((-moz-orient: inline) and (not (color:rgb(from red r g b)))){*,:before,:after,::backdrop{--tw-font-weight: initial}}}\n/*! tailwindcss v4.3.3 | MIT License | https://tailwindcss.com */\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: i1.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i2.AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }, { kind: "ngmodule", type: AXButtonModule }, { kind: "component", type: i1$1.AXButtonComponent, selector: "ax-button", inputs: ["disabled", "size", "tabIndex", "color", "look", "text", "toggleable", "selected", "iconOnly", "type", "loadingText"], outputs: ["onBlur", "onFocus", "onClick", "selectedChange", "toggleableChange", "lookChange", "colorChange", "disabledChange", "loadingTextChange"] }, { kind: "directive", type: AXPanViewDirective, selector: "[axPanView]", inputs: ["zoomStep", "minZoom", "maxZoom", "freeMode", "fitContent", "disablePan", "disableZoom", "wrapperClasses", "panX", "panY", "zoom"], outputs: ["panXChange", "panYChange", "zoomChange", "positionChange"], exportAs: ["axPanView"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPWorkflowDesignerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'axp-workflow-designer', imports: [CommonModule, AXDecoratorModule, AXButtonModule, AXPanViewDirective], changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, host: {
+                        class: 'axp-workflow-designer-host',
+                        '(window:keydown)': 'onWindowKeydown($event)',
+                    }, template: "<div class=\"axp-workflow-designer\" [ngStyle]=\"gridStyle()\">\n  <div\n    #surface\n    class=\"axp-workflow-designer__surface\"\n    axPanView\n    [(panX)]=\"panX\"\n    [(panY)]=\"panY\"\n    [(zoom)]=\"panZoomLevel\"\n    [maxZoom]=\"10000\"\n    [freeMode]=\"true\"\n    [fitContent]=\"true\"\n    wrapperClasses=\"h\"\n    [ngStyle]=\"surfaceStyle()\"\n    (pointerdown)=\"onSurfacePointerDown($event)\"\n    (click)=\"onSurfaceClick($event)\"\n    (dblclick)=\"onSurfaceDoubleClick($event)\"\n    (dragover)=\"onCanvasDragOver($event)\"\n    (drop)=\"onCanvasDrop($event)\"\n  >\n    <svg\n      class=\"axp-workflow-designer__svg\"\n      width=\"100%\"\n      height=\"100%\"\n      preserveAspectRatio=\"xMinYMin meet\"\n    >\n      <defs>\n        <marker\n          [attr.id]=\"svgMarkerId\"\n          markerWidth=\"6\"\n          markerHeight=\"6\"\n          refX=\"3.9\"\n          refY=\"3\"\n          orient=\"auto\"\n        >\n          <path\n            d=\"M0,0 L4,3 L0,6 Q1.5,3 0,0 Z\"\n            class=\"axp-workflow-designer__arrow-head\"\n          ></path>\n        </marker>\n      </defs>\n      @for (c of model().connectors; track c.id) {\n        <path\n          class=\"axp-workflow-designer__edge-hit\"\n          [attr.d]=\"connectorPathD(c)\"\n          fill=\"none\"\n          stroke=\"transparent\"\n          stroke-width=\"16\"\n          pointer-events=\"stroke\"\n          (click)=\"onConnectorClick(c, $event)\"\n          (dblclick)=\"onConnectorDoubleClick(c, $event)\"\n        />\n        <path\n          [class]=\"connectorEdgeClasses(c)\"\n          [attr.d]=\"connectorPathD(c)\"\n          fill=\"none\"\n          [attr.marker-end]=\"'url(#' + svgMarkerId + ')'\"\n        />\n      }\n      @if (linkDrag()) {\n        <path\n          class=\"axp-workflow-designer__edge-preview\"\n          [attr.d]=\"previewPath()\"\n          fill=\"none\"\n        />\n      }\n      @if (showPortLabels()) {\n        @for (node of model().nodes; track node.id) {\n          @for (port of node.inboundPorts; track port.id) {\n            @if (portLabelText(port)) {\n              <text\n                class=\"axp-workflow-designer__port-label-svg\"\n                [attr.x]=\"portLabelX(node, port)\"\n                [attr.y]=\"portLabelY(node, port)\"\n                [attr.text-anchor]=\"portLabelAnchor(node, port)\"\n              >\n                {{ portLabelText(port) }}\n              </text>\n            }\n          }\n          @for (port of node.outboundPorts; track port.id) {\n            @if (portLabelText(port)) {\n              <text\n                class=\"axp-workflow-designer__port-label-svg\"\n                [attr.x]=\"portLabelX(node, port)\"\n                [attr.y]=\"portLabelY(node, port)\"\n                [attr.text-anchor]=\"portLabelAnchor(node, port)\"\n              >\n                {{ portLabelText(port) }}\n              </text>\n            }\n          }\n        }\n      }\n    </svg>\n\n    @for (c of model().connectors; track c.id) {\n      @if (isConnectorActive(c.id) && !isConnectorReadonly(c)) {\n        <div\n          class=\"axp-workflow-designer__connector-actions\"\n          [style.left.px]=\"connectorMidpoint(c).x - 16\"\n          [style.top.px]=\"connectorMidpoint(c).y - 16\"\n        >\n          <ax-button\n            look=\"blank\"\n            class=\"ax-sm axp-workflow-designer__icon-btn\"\n            (onClick)=\"removeConnector(c)\"\n          >\n            <ax-icon class=\"fa-solid fa-minus\"></ax-icon>\n          </ax-button>\n        </div>\n      }\n    }\n\n    @for (node of model().nodes; track node.id) {\n      <div\n        class=\"axp-workflow-designer__node\"\n        [class.axp-workflow-designer__node--active]=\"isNodeActive(node.id)\"\n        [class.axp-workflow-designer__node--highlighted]=\"\n          isNodeHighlighted(node.id)\n        \"\n        [style.left.px]=\"nodeSurfaceLeft(node)\"\n        [style.top.px]=\"nodeSurfaceTop(node)\"\n        [style.width.px]=\"node.size.width\"\n        [style.height.px]=\"node.size.height\"\n        (pointerdown)=\"onNodePointerDown(node, $event)\"\n        (click)=\"onNodeClick(node, $event)\"\n        (dblclick)=\"onNodeDoubleClick(node, $event)\"\n        (contextmenu)=\"onNodeContextMenu(node, $event)\"\n      >\n        <div [class]=\"nodeShapeClasses(node)\">\n          <div\n            class=\"axp-workflow-designer__node-body\"\n            (pointerdown)=\"onNodeBodyPointerDown(node, $event)\"\n          >\n            @if (nodeBodyTemplate(); as tpl) {\n              <ng-container\n                [ngTemplateOutlet]=\"tpl\"\n                [ngTemplateOutletContext]=\"templateContext(node)\"\n              />\n            } @else {\n              <div class=\"axp-workflow-designer__node-default\">\n                @if (node.icon) {\n                  <ax-icon\n                    class=\"axp-workflow-designer__node-default-icon\"\n                    [class]=\"node.icon\"\n                  ></ax-icon>\n                }\n                <span class=\"axp-workflow-designer__node-default-title\">{{\n                  node.title\n                }}</span>\n              </div>\n            }\n          </div>\n        </div>\n\n        @for (port of node.inboundPorts; track port.id) {\n          <div\n            class=\"axp-workflow-designer__port-cluster\"\n            [class.axp-workflow-designer__port-cluster--side-top]=\"\n              port.side === 'top'\n            \"\n            [class.axp-workflow-designer__port-cluster--side-right]=\"\n              port.side === 'right'\n            \"\n            [class.axp-workflow-designer__port-cluster--side-bottom]=\"\n              port.side === 'bottom'\n            \"\n            [class.axp-workflow-designer__port-cluster--side-left]=\"\n              port.side === 'left'\n            \"\n            [ngStyle]=\"portClusterStyle(node, port)\"\n          >\n            <button\n              type=\"button\"\n              class=\"axp-workflow-designer__port axp-workflow-designer__port--inbound\"\n              [class.axp-workflow-designer__port--active]=\"\n                isPortActive(node.id, port.id)\n              \"\n              [class.axp-workflow-designer__port--link-hover]=\"\n                isPortLinkHoverTarget(node.id, port.id)\n              \"\n              [class.axp-workflow-designer__port--disabled]=\"port.disabled\"\n              [disabled]=\"isNodeReadonly(node) || port.disabled === true\"\n              (pointerdown)=\"onPortPointerDown(node, port, $event)\"\n            ></button>\n          </div>\n        }\n        @for (port of node.outboundPorts; track port.id) {\n          <div\n            class=\"axp-workflow-designer__port-cluster\"\n            [class.axp-workflow-designer__port-cluster--side-top]=\"\n              port.side === 'top'\n            \"\n            [class.axp-workflow-designer__port-cluster--side-right]=\"\n              port.side === 'right'\n            \"\n            [class.axp-workflow-designer__port-cluster--side-bottom]=\"\n              port.side === 'bottom'\n            \"\n            [class.axp-workflow-designer__port-cluster--side-left]=\"\n              port.side === 'left'\n            \"\n            [ngStyle]=\"portClusterStyle(node, port)\"\n          >\n            <button\n              type=\"button\"\n              class=\"axp-workflow-designer__port axp-workflow-designer__port--outbound\"\n              [class.axp-workflow-designer__port--active]=\"\n                isPortActive(node.id, port.id)\n              \"\n              [class.axp-workflow-designer__port--disabled]=\"port.disabled\"\n              [disabled]=\"isNodeReadonly(node) || port.disabled === true\"\n              (pointerdown)=\"onPortPointerDown(node, port, $event)\"\n            ></button>\n          </div>\n        }\n\n        @if (isNodeActive(node.id) && !isNodeReadonly(node)) {\n          <span\n            class=\"axp-workflow-designer__resize axp-workflow-designer__resize--nw\"\n            (pointerdown)=\"onResizePointerDown(node, 'nw', $event)\"\n          ></span>\n          <span\n            class=\"axp-workflow-designer__resize axp-workflow-designer__resize--ne\"\n            (pointerdown)=\"onResizePointerDown(node, 'ne', $event)\"\n          ></span>\n          <span\n            class=\"axp-workflow-designer__resize axp-workflow-designer__resize--sw\"\n            (pointerdown)=\"onResizePointerDown(node, 'sw', $event)\"\n          ></span>\n          <span\n            class=\"axp-workflow-designer__resize axp-workflow-designer__resize--se\"\n            (pointerdown)=\"onResizePointerDown(node, 'se', $event)\"\n          ></span>\n        }\n      </div>\n    }\n  </div>\n</div>\n", styles: ["@layer properties;.axp-workflow-designer-host{box-sizing:border-box;display:block;height:100%;width:100%;min-height:360px;user-select:none;-webkit-user-select:none}.axp-workflow-designer{display:flex;height:100%;width:100%;min-height:inherit}.axp-workflow-designer .axp-workflow-designer__surface{position:relative;min-height:100%;min-width:100%;flex:auto;overflow:auto;border-radius:10px;user-select:none;-webkit-user-select:none}.axp-workflow-designer .axp-workflow-designer__surface::ng-deep .pan-view__wrapper{height:100%;width:100%}.axp-workflow-designer .axp-workflow-designer__svg{pointer-events:none;position:absolute;inset:0;height:100%;width:100%;z-index:1}.axp-workflow-designer .axp-workflow-designer__edge-hit{pointer-events:stroke;cursor:pointer}.axp-workflow-designer .axp-workflow-designer__edge{pointer-events:none;stroke:rgb(var(--ax-sys-color-neutral-500));stroke-width:2;transition:stroke .12s ease}.axp-workflow-designer .axp-workflow-designer__edge.primary-surface:not(.axp-workflow-designer__edge--active){stroke:rgb(var(--ax-sys-color-primary-500))}.axp-workflow-designer .axp-workflow-designer__edge.secondary-surface:not(.axp-workflow-designer__edge--active){stroke:rgb(var(--ax-sys-color-secondary-500))}.axp-workflow-designer .axp-workflow-designer__edge.success-surface:not(.axp-workflow-designer__edge--active){stroke:rgb(var(--ax-sys-color-success-500))}.axp-workflow-designer .axp-workflow-designer__edge.warning-surface:not(.axp-workflow-designer__edge--active){stroke:rgb(var(--ax-sys-color-warning-500))}.axp-workflow-designer .axp-workflow-designer__edge.danger-surface:not(.axp-workflow-designer__edge--active){stroke:rgb(var(--ax-sys-color-danger-500))}.axp-workflow-designer .axp-workflow-designer__edge--active{stroke:rgb(var(--ax-sys-color-primary-500));stroke-dasharray:2}.axp-workflow-designer .axp-workflow-designer__edge-preview{pointer-events:none;stroke:rgb(var(--ax-sys-color-primary-400));stroke-width:2;stroke-dasharray:6 4}.axp-workflow-designer .axp-workflow-designer__port-label-svg{fill:rgb(var(--ax-sys-color-on-surface));font-size:10px;font-weight:600;dominant-baseline:middle;pointer-events:none;paint-order:stroke;stroke:rgb(var(--ax-sys-color-surface));stroke-width:4px;stroke-linejoin:round}.axp-workflow-designer .axp-workflow-designer__arrow-head{fill:rgb(var(--ax-sys-color-neutral-500))}.axp-workflow-designer .axp-workflow-designer__connector-actions{position:absolute;display:flex;align-items:center;justify-content:center;z-index:4}.axp-workflow-designer .axp-workflow-designer__icon-btn{border-radius:999px;user-select:none;-webkit-user-select:none}.axp-workflow-designer .axp-workflow-designer__node{position:absolute;box-sizing:border-box;z-index:2;user-select:none;-webkit-user-select:none}.axp-workflow-designer .axp-workflow-designer__node.axp-workflow-designer__node--active .axp-workflow-designer__node-shape{border:2px dotted rgb(var(--ax-sys-color-primary-500))}.axp-workflow-designer .axp-workflow-designer__node.axp-workflow-designer__node--highlighted .axp-workflow-designer__node-shape{border:2px solid rgb(var(--ax-sys-color-primary-500));box-shadow:0 0 0 3px rgb(var(--ax-sys-color-primary-surface))}.axp-workflow-designer .axp-workflow-designer__node-shape{position:absolute;inset:0;box-sizing:border-box;overflow:visible;background:rgb(var(--ax-sys-color-surface))}.axp-workflow-designer .axp-workflow-designer__node-shape.axp-primary-surface{background:rgb(var(--ax-sys-color-primary-surface));color:rgb(var(--ax-sys-color-on-primary-surface))}.axp-workflow-designer .axp-workflow-designer__node-shape.axp-secondary-surface{background:rgb(var(--ax-sys-color-secondary-surface));color:rgb(var(--ax-sys-color-on-secondary-surface))}.axp-workflow-designer .axp-workflow-designer__node-shape.axp-success-surface{background:rgb(var(--ax-sys-color-success-surface));color:rgb(var(--ax-sys-color-on-success-surface))}.axp-workflow-designer .axp-workflow-designer__node-shape.axp-warning-surface{background:rgb(var(--ax-sys-color-warning-surface));color:rgb(var(--ax-sys-color-on-warning-surface))}.axp-workflow-designer .axp-workflow-designer__node-shape.axp-danger-surface{background:rgb(var(--ax-sys-color-danger-surface));color:rgb(var(--ax-sys-color-on-danger-surface))}.axp-workflow-designer .axp-workflow-designer__node-shape.axp-primary-border{border:2px solid rgb(var(--ax-sys-color-border-primary-surface))}.axp-workflow-designer .axp-workflow-designer__node-shape.axp-secondary-border{border:2px solid rgb(var(--ax-sys-color-border-secondary-surface))}.axp-workflow-designer .axp-workflow-designer__node-shape.axp-success-border{border:2px solid rgb(var(--ax-sys-color-border-success-surface))}.axp-workflow-designer .axp-workflow-designer__node-shape.axp-warning-border{border:2px solid rgb(var(--ax-sys-color-border-warning-surface))}.axp-workflow-designer .axp-workflow-designer__node-shape.axp-danger-border{border:2px solid rgb(var(--ax-sys-color-border-danger-surface))}.axp-workflow-designer .axp-workflow-designer__node-shape--rectangle{border-radius:4px}.axp-workflow-designer .axp-workflow-designer__node-shape--rounded-rectangle{border-radius:14px}.axp-workflow-designer .axp-workflow-designer__node-shape--circle,.axp-workflow-designer .axp-workflow-designer__node-shape--ellipse{border-radius:50%}.axp-workflow-designer .axp-workflow-designer__node-shape--diamond{border-radius:0;clip-path:polygon(50% 0%,100% 50%,50% 100%,0% 50%)}.axp-workflow-designer .axp-workflow-designer__node-body{position:absolute;inset:0;display:flex;cursor:grab;align-items:center;justify-content:center;padding:8px 12px;touch-action:none;user-select:none;-webkit-user-select:none}.axp-workflow-designer .axp-workflow-designer__node-default{display:flex;min-width:0px;align-items:center;gap:8px}.axp-workflow-designer .axp-workflow-designer__node-default-icon{flex-shrink:0}.axp-workflow-designer .axp-workflow-designer__node-default-title{overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-size:var(--text-sm, .875rem);line-height:var(--tw-leading, var(--text-sm--line-height, calc(1.25 / .875)));--tw-font-weight: var(--font-weight-semibold, 600);font-weight:var(--font-weight-semibold, 600)}.axp-workflow-designer .axp-workflow-designer__port-cluster{pointer-events:none;position:absolute;overflow:visible;width:0;height:0;transform:translate(-50%,-50%);z-index:3}.axp-workflow-designer .axp-workflow-designer__port{position:absolute;flex-shrink:0;cursor:crosshair;border-radius:calc(infinity * 1px);left:50%;top:50%;transform:translate(-50%,-50%);width:14px;height:14px;padding:0;border:1px solid rgb(var(--ax-sys-color-surface));touch-action:none;pointer-events:auto;transition:transform .12s ease}.axp-workflow-designer .axp-workflow-designer__port:disabled{opacity:.45;cursor:not-allowed}.axp-workflow-designer .axp-workflow-designer__port--inbound{background:rgb(var(--ax-sys-color-success-500))}.axp-workflow-designer .axp-workflow-designer__port--outbound{background:rgb(var(--ax-sys-color-primary-500))}.axp-workflow-designer .axp-workflow-designer__port--active{box-shadow:0 0 0 3px #3b82f659}.axp-workflow-designer .axp-workflow-designer__port--link-hover{border:1px solid rgb(var(--ax-sys-color-primary-500));transform:translate(-50%,-50%) scale(1.12)}.axp-workflow-designer .axp-workflow-designer__port--disabled{opacity:.45;cursor:not-allowed}.axp-workflow-designer .axp-workflow-designer__resize{position:absolute;border-radius:calc(infinity * 1px);width:7px;height:7px;background:rgb(var(--ax-sys-color-primary-500));border:1px solid rgb(var(--ax-sys-color-surface));z-index:4;touch-action:none;user-select:none;-webkit-user-select:none}.axp-workflow-designer .axp-workflow-designer__resize--nw{left:-6px;top:-6px;cursor:nwse-resize}.axp-workflow-designer .axp-workflow-designer__resize--ne{right:-6px;top:-6px;cursor:nesw-resize}.axp-workflow-designer .axp-workflow-designer__resize--sw{left:-6px;bottom:-6px;cursor:nesw-resize}.axp-workflow-designer .axp-workflow-designer__resize--se{right:-6px;bottom:-6px;cursor:nwse-resize}@property --tw-font-weight{syntax: \"*\"; inherits: false;}@layer properties{@supports ((-webkit-hyphens: none) and (not (margin-trim: inline))) or ((-moz-orient: inline) and (not (color:rgb(from red r g b)))){*,:before,:after,::backdrop{--tw-font-weight: initial}}}\n/*! tailwindcss v4.3.3 | MIT License | https://tailwindcss.com */\n"] }]
+        }], ctorParameters: () => [], propDecorators: { model: [{ type: i0.Input, args: [{ isSignal: true, alias: "model", required: true }] }], modelChange: [{ type: i0.Output, args: ["modelChange"] }], readonly: [{ type: i0.Input, args: [{ isSignal: true, alias: "readonly", required: false }] }], highlightedNodeIds: [{ type: i0.Input, args: [{ isSignal: true, alias: "highlightedNodeIds", required: false }] }], gridSize: [{ type: i0.Input, args: [{ isSignal: true, alias: "gridSize", required: false }] }], snapToGrid: [{ type: i0.Input, args: [{ isSignal: true, alias: "snapToGrid", required: false }] }], connectionPreviewStyle: [{ type: i0.Input, args: [{ isSignal: true, alias: "connectionPreviewStyle", required: false }] }], backgroundPattern: [{ type: i0.Input, args: [{ isSignal: true, alias: "backgroundPattern", required: false }] }], zoomChange: [{ type: i0.Output, args: ["zoomChange"] }], canConnect: [{ type: i0.Input, args: [{ isSignal: true, alias: "canConnect", required: false }] }], paletteItems: [{ type: i0.Input, args: [{ isSignal: true, alias: "paletteItems", required: false }] }], showPortLabels: [{ type: i0.Input, args: [{ isSignal: true, alias: "showPortLabels", required: false }] }], nodeBodyTemplate: [{ type: i0.Input, args: [{ isSignal: true, alias: "nodeBodyTemplate", required: false }] }], designerPointerDown: [{ type: i0.Output, args: ["designerPointerDown"] }], designerClick: [{ type: i0.Output, args: ["designerClick"] }], designerDoubleClick: [{ type: i0.Output, args: ["designerDoubleClick"] }], nodePointerDown: [{ type: i0.Output, args: ["nodePointerDown"] }], nodeClick: [{ type: i0.Output, args: ["nodeClick"] }], nodeDoubleClick: [{ type: i0.Output, args: ["nodeDoubleClick"] }], nodeContextMenu: [{ type: i0.Output, args: ["nodeContextMenu"] }], nodeDragStart: [{ type: i0.Output, args: ["nodeDragStart"] }], nodeDragEnd: [{ type: i0.Output, args: ["nodeDragEnd"] }], portPointerDown: [{ type: i0.Output, args: ["portPointerDown"] }], linkDragStart: [{ type: i0.Output, args: ["linkDragStart"] }], linkDragMove: [{ type: i0.Output, args: ["linkDragMove"] }], linkDragEnd: [{ type: i0.Output, args: ["linkDragEnd"] }], connectorClick: [{ type: i0.Output, args: ["connectorClick"] }], connectorDoubleClick: [{ type: i0.Output, args: ["connectorDoubleClick"] }], connectionCreated: [{ type: i0.Output, args: ["connectionCreated"] }], connectionRejected: [{ type: i0.Output, args: ["connectionRejected"] }], activationChange: [{ type: i0.Output, args: ["activationChange"] }], surfaceRef: [{ type: i0.ViewChild, args: ['surface', { isSignal: true }] }], panViewRef: [{ type: i0.ViewChild, args: [i0.forwardRef(() => AXPanViewDirective), { isSignal: true }] }] } });
+
+/**
+ * Makes any host element a draggable palette source. Set `[axpWorkflowPaletteItem]="item"` and optional outputs.
+ * Drop target: `axp-workflow-designer` canvas (same MIME as drag payload).
+ */
+class AXPWorkflowPaletteItemDragDirective {
+    constructor() {
+        /** Palette definition serialized into the drag payload. */
+        this.axpWorkflowPaletteItem = input.required({ ...(ngDevMode ? { debugName: "axpWorkflowPaletteItem" } : /* istanbul ignore next */ {}), alias: 'axpWorkflowPaletteItem' });
+        /** When true, drag is disabled. */
+        this.axpWorkflowPaletteDragDisabled = input(false, { ...(ngDevMode ? { debugName: "axpWorkflowPaletteDragDisabled" } : /* istanbul ignore next */ {}), alias: 'axpWorkflowPaletteDragDisabled' });
+        this.axpWorkflowPaletteDragStart = output({
+            alias: 'axpWorkflowPaletteDragStart',
+        });
+        this.axpWorkflowPaletteDragEnd = output({
+            alias: 'axpWorkflowPaletteDragEnd',
+        });
+        this.hostDraggable = computed(() => (this.axpWorkflowPaletteDragDisabled() ? null : true), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "hostDraggable" }] : /* istanbul ignore next */ []));
+        this.lastItem = null;
+    }
+    onDragStart(event) {
+        if (this.axpWorkflowPaletteDragDisabled()) {
+            event.preventDefault();
+            return;
+        }
+        const item = this.axpWorkflowPaletteItem();
+        this.lastItem = item;
+        event.dataTransfer?.setData(AXP_WORKFLOW_PALETTE_MIME, JSON.stringify(item));
+        event.dataTransfer?.setData('text/plain', item.title);
+        if (event.dataTransfer)
+            event.dataTransfer.effectAllowed = 'copy';
+        this.axpWorkflowPaletteDragStart.emit({ item, event });
+    }
+    onDragEnd(event) {
+        this.axpWorkflowPaletteDragEnd.emit({ item: this.lastItem, event });
+        this.lastItem = null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPWorkflowPaletteItemDragDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.0.8", type: AXPWorkflowPaletteItemDragDirective, isStandalone: true, selector: "[axpWorkflowPaletteItem]", inputs: { axpWorkflowPaletteItem: { classPropertyName: "axpWorkflowPaletteItem", publicName: "axpWorkflowPaletteItem", isSignal: true, isRequired: true, transformFunction: null }, axpWorkflowPaletteDragDisabled: { classPropertyName: "axpWorkflowPaletteDragDisabled", publicName: "axpWorkflowPaletteDragDisabled", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { axpWorkflowPaletteDragStart: "axpWorkflowPaletteDragStart", axpWorkflowPaletteDragEnd: "axpWorkflowPaletteDragEnd" }, host: { listeners: { "dragstart": "onDragStart($event)", "dragend": "onDragEnd($event)" }, properties: { "attr.draggable": "hostDraggable()" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPWorkflowPaletteItemDragDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[axpWorkflowPaletteItem]',
+                    host: {
+                        '[attr.draggable]': 'hostDraggable()',
+                        '(dragstart)': 'onDragStart($event)',
+                        '(dragend)': 'onDragEnd($event)',
+                    },
+                }]
+        }], propDecorators: { axpWorkflowPaletteItem: [{ type: i0.Input, args: [{ isSignal: true, alias: "axpWorkflowPaletteItem", required: true }] }], axpWorkflowPaletteDragDisabled: [{ type: i0.Input, args: [{ isSignal: true, alias: "axpWorkflowPaletteDragDisabled", required: false }] }], axpWorkflowPaletteDragStart: [{ type: i0.Output, args: ["axpWorkflowPaletteDragStart"] }], axpWorkflowPaletteDragEnd: [{ type: i0.Output, args: ["axpWorkflowPaletteDragEnd"] }] } });
+
+//#region ---- Point & geometry ----
+//#endregion
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AXPMenuManagementService as A, snapPoint as B, snapScalar as C, REST_API_GENERATOR_WIDGET_NAME as R, REST_API_GENERATOR_IMPORT_DEBOUNCE_MS as a, AXMPlatformManagementModule as b, createEmptyRestApiOutput as c, AXPWorkflowDesignerComponent as d, AXPWorkflowPaletteItemDragDirective as e, formatRestApiSummary as f, AXP_WORKFLOW_PALETTE_MIME as g, hasParsedContent as h, arrangeWorkflowDiagram as i, cloneDiagram as j, connectorPath as k, createNodeFromPaletteItem as l, createPortsFromPalette as m, normalizeRestApiOutput as n, createWorkflowConnectorId as o, parseHttpRequest as p, createWorkflowNodeId as q, createWorkflowPortId as r, defaultCanConnectRequest as s, findConnector as t, findNode as u, findPort as v, parsePaletteItemDragPayload as w, portAnchorOnNode as x, portCanvasPosition as y, routeOrthogonalConnector as z };
+//# sourceMappingURL=acorex-platform-module-platform-management-client-acorex-platform-module-platform-management-client-V_ao4WVM.mjs.map