@lowdefy/client 4.7.3 → 5.1.0

package/dist/createHandleError.js

@@ -17,6 +17,12 @@ import { serializer } from '@lowdefy/helpers';
 function createHandleError(lowdefy) {
     const loggedErrors = new Set();
     const logger = lowdefy._internal.logger;
+    function logError(error) {
+        if (!(error instanceof UserError)) {
+            lowdefy._runtimeErrorCallback?.(error);
+        }
+        logger.error(error);
+    }
     return async function handleError(error) {
         const errorKey = `${error.message}:${error.configKey || ''}`;
         if (loggedErrors.has(errorKey)) {
@@ -25,14 +31,14 @@ function createHandleError(lowdefy) {
         loggedErrors.add(errorKey);
         // UserError is client-only — log to browser console, never send to server
         if (error instanceof UserError) {
-            logger.error(error);
+            logError(error);
             return;
         }
         // Send known error types to server for logging with location resolution
         if (error.isLowdefyError) {
             // Server-originated errors already have source resolved — just display locally
             if (error.source) {
-                logger.error(error);
+                logError(error);
                 return;
             }
             // Client-originated errors — send to server for logging + location resolution
@@ -54,18 +60,18 @@ function createHandleError(lowdefy) {
                     // If server produced a consolidated ConfigError, log it and return early
                     // (cause chain includes original error)
                     if (serializedConfigError) {
-                        logger.error(serializer.deserialize(serializedConfigError));
+                        logError(serializer.deserialize(serializedConfigError));
                         return;
                     }
                 }
             } catch  {
             // Server logging failed - continue with local console
             }
-            logger.error(error);
+            logError(error);
             return;
         }
         // Other errors - just log locally
-        logger.error(error);
+        logError(error);
     };
 }
 export default createHandleError;

package/dist/createIcon.js

@@ -13,10 +13,10 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import React from 'react';
-import classNames from 'classnames';
 import { omit, type } from '@lowdefy/helpers';
 import Icon from '@ant-design/icons';
-import { blockDefaultProps, ErrorBoundary, makeCssClass } from '@lowdefy/block-utils';
+import { cn, withBlockDefaults, ErrorBoundary } from '@lowdefy/block-utils';
+import iconStyles from './style.module.css';
 const lowdefyProps = [
     'actionLog',
     'basePath',
@@ -30,6 +30,7 @@ const lowdefyProps = [
     'registerEvent',
     'registerMethod',
     'schemaErrors',
+    'styles',
     'validation'
 ];
 const createIcon = (Icons)=>{
@@ -42,22 +43,20 @@ const createIcon = (Icons)=>{
         let spacedTitle = title.replace(/([A-Z])/g, ' $1').trim();
         return spacedTitle.substring(spacedTitle.indexOf(' ') + 1);
     };
-    const IconBlock = ({ blockId, events, methods, onClick, properties, ...props })=>{
+    const IconBlock = ({ blockId, classNames = {}, events, methods, onClick, properties, styles = {}, ...props })=>{
         const propertiesObj = type.isString(properties) ? {
             name: properties
         } : properties;
         const spin = (propertiesObj.spin || events.onClick?.loading) && !propertiesObj.disableLoadingIcon;
         const iconProps = {
             id: blockId,
-            className: classNames({
-                [makeCssClass([
-                    {
-                        cursor: (onClick || events.onClick) && 'pointer'
-                    },
-                    propertiesObj.style
-                ])]: true,
-                'icon-spin': spin
+            className: cn(classNames.element, {
+                [iconStyles['icon-spin']]: spin
             }),
+            style: {
+                cursor: onClick || events.onClick ? 'pointer' : undefined,
+                ...styles.element
+            },
             rotate: propertiesObj.rotate,
             color: propertiesObj.color,
             title: propertiesObj.title ?? formatTitle(propertiesObj.name),
@@ -87,7 +86,6 @@ const createIcon = (Icons)=>{
     const AntIcon = (all)=>/*#__PURE__*/ React.createElement(Icon, {
             component: ()=>/*#__PURE__*/ React.createElement(IconBlock, all)
         });
-    AntIcon.defaultProps = blockDefaultProps;
-    return AntIcon;
+    return withBlockDefaults(AntIcon);
 };
 export default createIcon;

package/dist/createShortcutBadge.js

@@ -0,0 +1,113 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import React from 'react';
+import styles from './style.module.css';
+const SPECIAL_KEY_DISPLAY = {
+    Escape: 'Esc',
+    Enter: '↵',
+    Backspace: '⌫',
+    Delete: '⌦',
+    ArrowUp: '↑',
+    ArrowDown: '↓',
+    ArrowLeft: '←',
+    ArrowRight: '→',
+    Tab: '⇥',
+    Space: '␣'
+};
+const MAC_MODIFIERS = {
+    mod: '⌘',
+    shift: '⇧',
+    alt: '⌥',
+    ctrl: '⌃'
+};
+const WIN_MODIFIERS = {
+    mod: 'Ctrl',
+    shift: 'Shift',
+    alt: 'Alt',
+    ctrl: 'Ctrl'
+};
+let isMacCached = null;
+function isMac() {
+    if (isMacCached !== null) return isMacCached;
+    if (typeof navigator !== 'undefined') {
+        isMacCached = navigator.userAgentData?.platform === 'macOS' || /Mac|iPhone|iPad|iPod/.test(navigator.platform ?? '');
+    } else {
+        isMacCached = false;
+    }
+    return isMacCached;
+}
+function parseShortcut(shortcut) {
+    // Sequence: "g i" → ["G", "then", "I"]
+    if (shortcut.includes(' ') && !shortcut.includes('+')) {
+        const parts = shortcut.split(' ');
+        const result = [];
+        parts.forEach((part, i)=>{
+            if (i > 0) result.push('then');
+            result.push(displayKey(part));
+        });
+        return result;
+    }
+    if (shortcut.includes(' ')) {
+        // Sequence with modifiers: "mod+G mod+I"
+        const parts = shortcut.split(' ');
+        const result = [];
+        parts.forEach((part, i)=>{
+            if (i > 0) result.push('then');
+            result.push(...parsePart(part));
+        });
+        return result;
+    }
+    return parsePart(shortcut);
+}
+function parsePart(part) {
+    const segments = part.split('+');
+    if (segments.length === 1) {
+        return [
+            displayKey(segments[0])
+        ];
+    }
+    const key = segments[segments.length - 1];
+    const modifiers = segments.slice(0, -1);
+    const modMap = isMac() ? MAC_MODIFIERS : WIN_MODIFIERS;
+    const result = modifiers.map((mod)=>modMap[mod.toLowerCase()] || mod);
+    result.push(displayKey(key));
+    return [
+        result.join('\u2009')
+    ];
+}
+function displayKey(key) {
+    if (SPECIAL_KEY_DISPLAY[key]) return SPECIAL_KEY_DISPLAY[key];
+    if (key.length === 1) return key.toUpperCase();
+    return key;
+}
+function createShortcutBadge() {
+    function ShortcutBadge({ shortcut }) {
+        if (!shortcut) return null;
+        const primary = Array.isArray(shortcut) ? shortcut[0] : shortcut;
+        if (!primary) return null;
+        const segments = parseShortcut(primary);
+        return /*#__PURE__*/ React.createElement("span", {
+            className: styles['shortcut-badge']
+        }, segments.map((segment, i)=>segment === 'then' ? /*#__PURE__*/ React.createElement("span", {
+                key: i,
+                className: styles['shortcut-then']
+            }, "then") : /*#__PURE__*/ React.createElement("kbd", {
+                key: i,
+                className: styles['shortcut-kbd']
+            }, segment)));
+    }
+    return ShortcutBadge;
+}
+export default createShortcutBadge;

package/dist/createShortcutManager.js

@@ -0,0 +1,135 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { tinykeys } from 'tinykeys';
+const SPECIAL_KEYS = new Set([
+    'Escape',
+    'Enter',
+    'Backspace',
+    'Delete',
+    'ArrowUp',
+    'ArrowDown',
+    'ArrowLeft',
+    'ArrowRight',
+    'Tab',
+    'Space'
+]);
+const MODIFIER_MAP = {
+    mod: '$mod',
+    alt: 'Alt',
+    shift: 'Shift',
+    ctrl: 'Control'
+};
+const MODIFIER_VALUES = new Set([
+    '$mod',
+    'Alt',
+    'Shift',
+    'Control'
+]);
+function normalizeShortcut(shortcut) {
+    // Sequences are space-separated parts like "g i"
+    if (shortcut.includes(' ') && !shortcut.includes('+')) {
+        return shortcut.split(' ').map((part)=>normalizePart(part)).join(' ');
+    }
+    // Check for sequences that have modifiers: "mod+G mod+I" is invalid in tinykeys,
+    // but "g i" (no modifiers) is a sequence. Handle mixed case: split on space.
+    if (shortcut.includes(' ')) {
+        return shortcut.split(' ').map((part)=>normalizePart(part)).join(' ');
+    }
+    return normalizePart(shortcut);
+}
+function normalizePart(part) {
+    const segments = part.split('+');
+    if (segments.length === 1) {
+        // Single key, no modifiers
+        return normalizeKey(segments[0]);
+    }
+    const key = segments[segments.length - 1];
+    const modifiers = segments.slice(0, -1);
+    const normalizedModifiers = modifiers.map((mod)=>MODIFIER_MAP[mod.toLowerCase()] || mod);
+    return [
+        ...normalizedModifiers,
+        normalizeKey(key)
+    ].join('+');
+}
+function normalizeKey(key) {
+    if (SPECIAL_KEYS.has(key)) return key;
+    if (key.length === 1) return key.toLowerCase();
+    return key;
+}
+function hasModifier(normalizedShortcut) {
+    // Check the first part (for sequences, only first part matters for suppression)
+    const firstPart = normalizedShortcut.split(' ')[0];
+    return firstPart.split('+').some((segment)=>MODIFIER_VALUES.has(segment));
+}
+function collectShortcuts(context) {
+    const entries = [];
+    const blockMap = context._internal.RootSlots.map;
+    Object.values(blockMap).forEach((block)=>{
+        if (!block.Events || !block.Events.events) return;
+        Object.entries(block.Events.events).forEach(([eventName, event])=>{
+            if (!event.shortcut) return;
+            const shortcuts = Array.isArray(event.shortcut) ? event.shortcut : [
+                event.shortcut
+            ];
+            shortcuts.forEach((s)=>entries.push({
+                    block,
+                    eventName,
+                    shortcut: s
+                }));
+        });
+    });
+    return entries;
+}
+function createShortcutManager() {
+    let unsubscribe = null;
+    function init(context) {
+        const entries = collectShortcuts(context);
+        if (entries.length === 0) return;
+        const shortcutMap = {};
+        // Last entry wins for duplicates
+        entries.forEach(({ block, eventName, shortcut })=>{
+            const normalized = normalizeShortcut(shortcut);
+            const modded = hasModifier(normalized);
+            shortcutMap[normalized] = (event)=>{
+                // Visibility gating
+                if (block.visibleEval && block.visibleEval.output === false) return;
+                // Input field suppression for non-modifier shortcuts
+                if (!modded) {
+                    const tag = event.target?.tagName;
+                    if (tag === 'INPUT' || tag === 'TEXTAREA' || event.target?.isContentEditable) {
+                        return;
+                    }
+                }
+                event.preventDefault();
+                block.triggerEvent({
+                    name: eventName
+                });
+            };
+        });
+        const win = context._internal.lowdefy._internal.globals.window;
+        unsubscribe = tinykeys(win, shortcutMap);
+    }
+    function destroy() {
+        if (unsubscribe) {
+            unsubscribe();
+            unsubscribe = null;
+        }
+    }
+    return {
+        init,
+        destroy
+    };
+}
+export default createShortcutManager;

package/dist/index.js

@@ -14,3 +14,4 @@
   limitations under the License.
 */ import Client from './Client.js';
 export default Client;
+export { default as useDarkMode } from './useDarkMode.js';

package/dist/initLowdefyContext.js

@@ -16,6 +16,7 @@
 import createAuthMethods from './auth/createAuthMethods.js';
 import createCallRequest from './createCallRequest.js';
 import createIcon from './createIcon.js';
+import createShortcutBadge from './createShortcutBadge.js';
 import createLinkComponent from './createLinkComponent.js';
 import createHandleError from './createHandleError.js';
 import { createBrowserLogger } from '@lowdefy/logger/browser';
@@ -25,8 +26,10 @@ function initLowdefyContext({ auth, Components, config, lowdefy, router, stage,
         lowdefy._internal = {
             actions: types.actions,
             blockComponents: types.blocks,
+            blockMetas: types.blockMetas ?? {},
             components: {
-                Icon: createIcon(types.icons)
+                Icon: createIcon(types.icons),
+                ShortcutBadge: createShortcutBadge()
             },
             displayMessage: ({ content })=>{
                 console.log(content);
@@ -54,6 +57,7 @@ function initLowdefyContext({ auth, Components, config, lowdefy, router, stage,
         lowdefy.contexts = {};
         lowdefy.inputs = {};
         lowdefy.lowdefyGlobal = config.rootConfig.lowdefyGlobal;
+        lowdefy.theme = config.rootConfig.theme ?? {};
         lowdefy._internal.callAPI = createCallAPI(lowdefy);
         lowdefy._internal.auth = createAuthMethods(lowdefy, auth);
         lowdefy._internal.callRequest = createCallRequest(lowdefy);
@@ -62,6 +66,7 @@ function initLowdefyContext({ auth, Components, config, lowdefy, router, stage,
         lowdefy._internal.updateBlock = (blockId)=>lowdefy._internal.updaters[blockId] && lowdefy._internal.updaters[blockId]();
         lowdefy._internal.logger = createBrowserLogger();
         lowdefy._internal.handleError = createHandleError(lowdefy);
+        lowdefy._internal.components.handleError = lowdefy._internal.handleError;
         if (stage === 'dev' || stage === 'e2e') {
             window.lowdefy = lowdefy;
         }

package/dist/style.module.css

@@ -0,0 +1,70 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+@layer components {
+  .icon-spin {
+    animation: spin 1s infinite linear;
+  }
+
+  @keyframes spin {
+    0% {
+      transform: rotate(0deg);
+    }
+
+    100% {
+      transform: rotate(360deg);
+    }
+  }
+
+  .shortcut-badge {
+    display: inline-flex;
+    align-items: center;
+    gap: 2px;
+    margin-left: var(--ant-margin-xs);
+    font-size: calc(var(--ant-font-size-sm) - 1px);
+    line-height: 1;
+    vertical-align: middle;
+  }
+
+  .shortcut-kbd {
+    display: inline-block;
+    padding: 2px 5px;
+    font-size: calc(var(--ant-font-size-sm) - 1px);
+    font-family:
+      system-ui,
+      -apple-system,
+      sans-serif;
+    background-color: var(--ant-color-fill-quaternary);
+    border-radius: var(--ant-border-radius-sm);
+    border: 1px solid var(--ant-color-border);
+  }
+
+  .shortcut-kbd + .shortcut-kbd {
+    border-left: none;
+    border-top-left-radius: 0;
+    border-bottom-left-radius: 0;
+  }
+
+  .shortcut-kbd:has(+ .shortcut-kbd) {
+    border-top-right-radius: 0;
+    border-bottom-right-radius: 0;
+  }
+
+  .shortcut-then {
+    margin: 0 2px;
+    font-size: calc(var(--ant-font-size-sm) - 2px);
+  }
+}

package/dist/useDarkMode.js

@@ -0,0 +1,147 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { useCallback, useEffect, useMemo, useState } from 'react';
+import { theme as antdTheme } from 'antd';
+const algorithmMap = {
+    default: antdTheme.defaultAlgorithm,
+    dark: antdTheme.darkAlgorithm,
+    compact: antdTheme.compactAlgorithm
+};
+function resolveAlgorithm(algorithm) {
+    if (Array.isArray(algorithm)) {
+        return algorithm.map((a)=>algorithmMap[a] || antdTheme.defaultAlgorithm);
+    }
+    return algorithmMap[algorithm] || antdTheme.defaultAlgorithm;
+}
+function stripDarkFromAlgorithm(algorithm) {
+    if (Array.isArray(algorithm)) {
+        const filtered = algorithm.filter((a)=>a !== 'dark');
+        return filtered.length > 0 ? filtered : 'default';
+    }
+    if (algorithm === 'dark') return 'default';
+    return algorithm;
+}
+function mergeAlgorithm(baseAlgorithm, isDark) {
+    if (!isDark) return baseAlgorithm;
+    const base = Array.isArray(baseAlgorithm) ? baseAlgorithm : baseAlgorithm ? [
+        baseAlgorithm
+    ] : [];
+    return [
+        ...base,
+        'dark'
+    ];
+}
+function resolveIsDark({ configDarkMode, userPreference, systemIsDark }) {
+    if (configDarkMode === 'dark') return true;
+    if (configDarkMode === 'light') return false;
+    // configDarkMode is 'system' or undefined — user preference decides
+    if (userPreference === 'dark') return true;
+    if (userPreference === 'light') return false;
+    // userPreference is 'system' — follow OS
+    return systemIsDark;
+}
+function mergeComponents(shared, mode) {
+    if (!shared && !mode) return undefined;
+    const keys = new Set([
+        ...Object.keys(shared ?? {}),
+        ...Object.keys(mode ?? {})
+    ]);
+    const merged = {};
+    keys.forEach((name)=>{
+        merged[name] = {
+            ...(shared ?? {})[name] ?? {},
+            ...(mode ?? {})[name] ?? {}
+        };
+    });
+    return merged;
+}
+function useDarkMode({ antd, configDarkMode }) {
+    const baseAlgorithm = antd?.algorithm;
+    const cleanAlgorithm = stripDarkFromAlgorithm(baseAlgorithm);
+    const [userPreference, setUserPreference] = useState(()=>{
+        return window.localStorage?.getItem('lowdefy_darkMode') ?? 'system';
+    });
+    const [systemIsDark, setSystemIsDark] = useState(()=>{
+        return window.matchMedia?.('(prefers-color-scheme: dark)')?.matches ?? false;
+    });
+    // Listen for OS theme changes
+    useEffect(()=>{
+        const mql = window.matchMedia?.('(prefers-color-scheme: dark)');
+        if (!mql?.addEventListener) return;
+        const handler = (e)=>setSystemIsDark(e.matches);
+        mql.addEventListener('change', handler);
+        return ()=>mql.removeEventListener('change', handler);
+    }, []);
+    const setPreference = useCallback((newPref)=>{
+        window.localStorage?.setItem('lowdefy_darkMode', newPref);
+        setUserPreference(newPref);
+    }, []);
+    window.__lowdefy_setDarkMode = setPreference;
+    const isDark = resolveIsDark({
+        configDarkMode,
+        userPreference,
+        systemIsDark
+    });
+    window.__lowdefy_isDark = isDark;
+    const sharedToken = antd?.token;
+    const lightToken = antd?.lightToken;
+    const darkToken = antd?.darkToken;
+    const sharedComponents = antd?.components;
+    const lightComponents = antd?.lightComponents;
+    const darkComponents = antd?.darkComponents;
+    const token = useMemo(()=>{
+        const modeToken = isDark ? darkToken : lightToken;
+        if (!sharedToken && !modeToken) return undefined;
+        return {
+            ...sharedToken ?? {},
+            ...modeToken ?? {}
+        };
+    }, [
+        isDark,
+        sharedToken,
+        lightToken,
+        darkToken
+    ]);
+    const components = useMemo(()=>mergeComponents(sharedComponents, isDark ? darkComponents : lightComponents), [
+        isDark,
+        sharedComponents,
+        lightComponents,
+        darkComponents
+    ]);
+    // Keep the <html> background in sync with the resolved mode. The _document.js
+    // inline script sets an initial background before hydration; this effect takes
+    // over once React is active and updates on every dark/light toggle.
+    const darkBg = darkToken?.colorBgLayout;
+    const lightBg = lightToken?.colorBgLayout;
+    useEffect(()=>{
+        if (isDark) {
+            document.documentElement.style.backgroundColor = darkBg ?? '#000';
+        } else if (lightBg) {
+            document.documentElement.style.backgroundColor = lightBg;
+        } else {
+            document.documentElement.style.removeProperty('background-color');
+        }
+    }, [
+        isDark,
+        darkBg,
+        lightBg
+    ]);
+    return {
+        algorithm: resolveAlgorithm(mergeAlgorithm(cleanAlgorithm, isDark)),
+        token,
+        components
+    };
+}
+export default useDarkMode;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lowdefy/client",
-  "version": "4.7.3",
+  "version": "5.1.0",
   "license": "Apache-2.0",
   "description": "Lowdefy Client",
   "homepage": "https://lowdefy.com",
@@ -33,24 +33,24 @@
     "dist/*"
   ],
   "dependencies": {
-    "@ant-design/icons": "4.8.0",
-    "@lowdefy/block-utils": "4.7.3",
-    "@lowdefy/engine": "4.7.3",
-    "@lowdefy/errors": "4.7.3",
-    "@lowdefy/helpers": "4.7.3",
-    "@lowdefy/layout": "4.7.3",
-    "@lowdefy/logger": "4.7.3",
-    "classnames": "2.3.2",
+    "@ant-design/icons": "6.1.0",
+    "antd": "6.3.1",
+    "@lowdefy/block-utils": "5.1.0",
+    "@lowdefy/engine": "5.1.0",
+    "@lowdefy/errors": "5.1.0",
+    "@lowdefy/helpers": "5.1.0",
+    "@lowdefy/layout": "5.1.0",
+    "@lowdefy/logger": "5.1.0",
     "react": "18.2.0",
-    "react-dom": "18.2.0"
+    "react-dom": "18.2.0",
+    "tinykeys": "^3.0.0"
   },
   "devDependencies": {
-    "@emotion/jest": "11.10.5",
     "@jest/globals": "28.1.3",
-    "@lowdefy/jest-yaml-transform": "4.7.3",
-    "@swc/cli": "0.1.63",
-    "@swc/core": "1.3.99",
-    "@swc/jest": "0.2.29",
+    "@lowdefy/jest-yaml-transform": "5.1.0",
+    "@swc/cli": "0.8.0",
+    "@swc/core": "1.15.18",
+    "@swc/jest": "0.2.39",
     "@testing-library/dom": "8.19.1",
     "@testing-library/react": "13.4.0",
     "@testing-library/user-event": "14.4.3",
@@ -63,7 +63,7 @@
     "access": "public"
   },
   "scripts": {
-    "build": "swc src --out-dir dist --config-file ../../.swcrc --delete-dir-on-start && pnpm copyfiles",
+    "build": "swc src --out-dir dist --config-file ../../.swcrc --cli-config-file ../../.swc-cli.json && pnpm copyfiles",
     "clean": "rm -rf dist",
     "copyfiles": "copyfiles -u 1 \"./src/**/*\" dist -e \"./src/**/*.js\" -e \"./src/**/*.yaml\" -e \"./src/**/*.snap\"",
     "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js"