@lowdefy/engine 0.0.0-experimental-20260929101721 → 0.0.0-experimental-20260929135001

package/dist/Block.js

@@ -507,10 +507,11 @@ let Block = class Block {
                             toDelete,
                             toSet
                         }));
-                    return;
+                } else {
+                    this.context._internal.State.republish(this.blockId, type.enforceType(this.meta.valueType, null));
                 }
-                this.context._internal.State.republish(this.blockId, type.enforceType(this.meta.valueType, null));
             }
+            // After the slots, so an input-container (an input with slots) republishes its own value.
             if (this.isInput()) {
                 this.context._internal.State.republish(this.blockId, this.value);
             }

package/dist/Events.js

@@ -31,8 +31,13 @@ let Events = class Events {
             this.events[eventName] = this.initEvent(this.block.events[eventName]);
         });
     }
+    // Events a block registers for its own machinery (Upload's policy request, a Table's row
+    // fetch). They are internal: see claimDomEvent.
     registerEvent({ name, actions }) {
-        this.events[name] = this.initEvent(actions);
+        this.events[name] = {
+            ...this.initEvent(actions),
+            internal: true
+        };
     }
     triggerEvent({ name, event, progress }) {
         this.context._internal.lowdefy.eventCallback?.({
@@ -55,7 +60,8 @@ let Events = class Events {
         const handledBy = claimDomEvent({
             blockId: this.block.blockId,
             bubble: eventDescription?.bubble === true,
-            hasActions: !type.isUndefined(eventDescription)
+            hasActions: !type.isUndefined(eventDescription),
+            internal: eventDescription?.internal === true
         });
         if (!type.isNull(handledBy)) {
             result.handledBy = handledBy;

package/dist/actions/createCallMethod.js

@@ -13,6 +13,7 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { applyArrayIndices, type } from '@lowdefy/helpers';
+import exemptFromDomEvent from '../exemptFromDomEvent.js';
 function createCallMethod({ arrayIndices, context }) {
     return function callMethod(params) {
         const { blockId, method, args = [] } = params;
@@ -29,6 +30,9 @@ function createCallMethod({ arrayIndices, context }) {
         if (!type.isFunction(blockMethod)) {
             throw new Error(`Failed to call method "${method}" on block "${blockId}". Check if "${method}" is a valid block method for block "${blockId}".`);
         }
+        exemptFromDomEvent({
+            blockId: block.blockId
+        });
         return blockMethod(...args);
     };
 }

package/dist/claimDomEvent.js

@@ -12,21 +12,48 @@
   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.
-*/ // DOM event -> id of the block whose event handled it. Weak, so dispatched events are collected.
-const domEventHandlers = new WeakMap();
-// A DOM event bubbles through every block that wraps its target, and each of those blocks may
-// fire an event for it: a Button click also reaches the clickable Card around it. The first
-// block with actions for the event handles it, and other blocks skip the same DOM event unless
-// the handling event sets `bubble: true`. window.event is the DOM event whose listeners are
-// running (React dispatches synchronously inside it), and undefined outside a DOM dispatch, so
-// events fired by actions, timers or requests are never affected.
-function claimDomEvent({ blockId, bubble, hasActions }) {
-    const domEvent = globalThis.window?.event;
-    if (!(domEvent instanceof globalThis.Event)) return null;
-    const handledBy = domEventHandlers.get(domEvent);
-    if (handledBy !== undefined && handledBy !== blockId) return handledBy;
+*/ import domEventClaims from './domEventClaims.js';
+import getDomEvent from './getDomEvent.js';
+import getPathIndex from './getPathIndex.js';
+// A DOM event bubbles through every block that wraps its target, and each of those blocks may fire
+// an event for it: a Button click also reaches the clickable Card around it. The innermost block on
+// the event's path with actions for the event handles it, and the blocks further out on the path
+// skip their events for the same DOM event, unless the handling event sets `bubble: true`.
+//
+// Only blocks the DOM event passed through take part. Blocks fire events for other reasons while
+// a DOM event is dispatched, and those are never skipped:
+// - A block off the path: a Table next to a Button fires onSelectionChange from the effect that
+//   commits the selection the Button's CallMethod cleared. React flushes that effect in a
+//   microtask inside the click listener, so window.event is still the click. The same holds for
+//   effects in React's scheduler `message` events, whose path has no blocks.
+// - A block inside the handling block: a Table in a clickable Card fires onSelectionChange for a
+//   checkbox after the Card's onClick ran. It runs, and holds the claim from then on.
+// - A block an action called a method on (exemptFromDomEvent), even when it is on the path: a
+//   Button in a Table's bulk action slot clearing the Table's selection.
+// - An internal event (registered by the block itself, like a Table's row fetch). It still claims
+//   an unclaimed DOM event, as the block's own handler would.
+function claimDomEvent({ blockId, bubble, hasActions, internal }) {
+    const domEvent = getDomEvent();
+    if (domEvent === null) return null;
+    const path = domEvent.composedPath();
+    const index = getPathIndex({
+        blockId,
+        path
+    });
+    if (index === -1) return null;
+    if (domEventClaims.exempt.get(domEvent)?.has(blockId)) return null;
+    const handledBy = domEventClaims.handledBy.get(domEvent);
+    if (handledBy !== undefined && handledBy !== blockId) {
+        const handledByIsInner = getPathIndex({
+            blockId: handledBy,
+            path
+        }) < index;
+        if (handledByIsInner) {
+            return internal === true ? null : handledBy;
+        }
+    }
     if (hasActions && !bubble) {
-        domEventHandlers.set(domEvent, blockId);
+        domEventClaims.handledBy.set(domEvent, blockId);
     }
     return null;
 }

package/dist/createContext.js

@@ -0,0 +1,151 @@
+/*
+  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 { serializer } from '@lowdefy/helpers';
+import { WebParser } from '@lowdefy/operators';
+import Actions from './Actions.js';
+import DependencyTracker from './tracking/DependencyTracker.js';
+import readMediaViewport from './tracking/readMediaViewport.js';
+import Slots from './Slots.js';
+import Requests from './Requests.js';
+import State from './State.js';
+import updateMedia from './tracking/updateMedia.js';
+import WebSockets from './WebSockets.js';
+const blockData = (config)=>{
+    const { slots, blockId, blocks, class: blockClass, events, field, id, layout, loading, pageId, properties, requests, required, skeleton, style, subscriptions, type, validate, visible } = config;
+    const result = {
+        slots,
+        blockId,
+        blocks,
+        class: blockClass,
+        events,
+        field,
+        id,
+        layout,
+        loading,
+        pageId,
+        properties,
+        requests,
+        required,
+        skeleton,
+        style,
+        subscriptions,
+        type,
+        validate,
+        visible
+    };
+    // Preserve ~k (configKey) for error tracing - it's non-enumerable so must be copied explicitly
+    if (config['~k']) {
+        Object.defineProperty(result, '~k', {
+            value: config['~k'],
+            enumerable: false,
+            writable: true,
+            configurable: true
+        });
+    }
+    return result;
+};
+// Builds an engine context around one root block: the page's root block for a
+// page context, and a block-less root carrying the app events for the app context.
+function createContext({ config, jsMap, lowdefy }) {
+    const { id } = config;
+    const ctx = {
+        id,
+        pageId: config.pageId,
+        eventLog: [],
+        jsMap,
+        requests: {},
+        state: {},
+        _internal: {
+            lowdefy,
+            // Config object reference for dynamic page memoization — identity marks
+            // which fetch this context was built from.
+            pageConfig: config,
+            // The viewport the page's blocks last evaluated _media against, or null without a window.
+            // updateMedia diffs a resize against it.
+            media: readMediaViewport({
+                lowdefy
+            }),
+            // The read recorder of the block evaluating itself, or null. Managed by DependencyTracker.
+            readRecorder: null,
+            rootBlock: blockData(config),
+            update: ()=>{},
+            // React updaters register here per block id when the context's Block
+            // components mount — scoped per context so rebuilding over a live
+            // context (dynamic page navigation, reset) never notifies the previous
+            // context's still-mounted components.
+            updaters: {}
+        }
+    };
+    const _internal = ctx._internal;
+    _internal.DependencyTracker = new DependencyTracker(ctx);
+    _internal.parser = new WebParser({
+        context: ctx,
+        operators: lowdefy._internal.operators
+    });
+    _internal.State = new State(ctx);
+    _internal.Actions = new Actions(ctx);
+    _internal.Requests = new Requests(ctx);
+    _internal.WebSockets = new WebSockets(ctx);
+    _internal.RootSlots = new Slots({
+        slots: {
+            root: {
+                blocks: [
+                    _internal.rootBlock
+                ]
+            }
+        },
+        context: ctx
+    });
+    _internal.RootSlots.init(serializer.copy(ctx.state));
+    // update({ changes }) is a dependency-tracked pass; a bare update() is a full pass.
+    _internal.update = (options)=>{
+        _internal.RootSlots.update(options);
+    };
+    _internal.runOnInit = async (progress)=>{
+        progress();
+        if (!_internal.onInitDone) {
+            await _internal.RootSlots.slots.root.blocks[0].triggerEvent({
+                name: 'onInit',
+                progress
+            });
+            _internal.update();
+            _internal.State.freezeState();
+            _internal.onInitDone = true;
+        }
+    };
+    _internal.runOnInitAsync = async (progress)=>{
+        if (_internal.onInitDone && !_internal.onInitAsyncDone) {
+            await _internal.RootSlots.slots.root.blocks[0].triggerEvent({
+                name: 'onInitAsync',
+                progress
+            });
+            _internal.onInitAsyncDone = true;
+        }
+    };
+    // Called by the client's debounced resize listener.
+    _internal.updateMedia = ()=>updateMedia({
+            context: ctx
+        });
+    // Page lifecycle events (onVisible, onHidden, onOnline, onOffline, onResize) are
+    // triggered on the page's root block by browser listeners attached in the client.
+    _internal.triggerPageEvent = ({ name, event, progress = ()=>undefined })=>_internal.RootSlots.slots.root.blocks[0].triggerEvent({
+            name,
+            event,
+            progress
+        });
+    ctx._internal.update();
+    return ctx;
+}
+export default createContext;

package/dist/domEventClaims.js

@@ -0,0 +1,22 @@
+/*
+  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.
+*/ // Per DOM event, weak so dispatched events are collected:
+// - handledBy: the id of the block whose event handled it.
+// - exempt: ids of blocks an action called a method on while it was dispatched.
+const domEventClaims = {
+    handledBy: new WeakMap(),
+    exempt: new WeakMap()
+};
+export default domEventClaims;

package/dist/exemptFromDomEvent.js

@@ -0,0 +1,27 @@
+/*
+  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 domEventClaims from './domEventClaims.js';
+import getDomEvent from './getDomEvent.js';
+// A block an action calls a method on acts for that action, not for the DOM event being
+// dispatched: the events it fires for it (at once, or from the effects the method causes) are
+// never skipped as copies of the DOM event bubbling through it. See claimDomEvent.
+function exemptFromDomEvent({ blockId }) {
+    const domEvent = getDomEvent();
+    if (domEvent === null) return;
+    const exempt = domEventClaims.exempt.get(domEvent) ?? new Set();
+    exempt.add(blockId);
+    domEventClaims.exempt.set(domEvent, exempt);
+}
+export default exemptFromDomEvent;

package/dist/getAppContext.js

@@ -0,0 +1,66 @@
+/*
+  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 createContext from './createContext.js';
+// App events are not page config: the app context runs them on a root without
+// blocks, so they have no page state, inputs or requests. Box is the root because
+// every app bundles it (a container, so it has no value in state).
+function getAppContext({ events, jsMap = {}, lowdefy }) {
+    if (lowdefy.appContext) {
+        return lowdefy.appContext;
+    }
+    const ctx = createContext({
+        config: {
+            id: 'app',
+            blockId: 'app',
+            type: 'Box',
+            events
+        },
+        jsMap,
+        lowdefy
+    });
+    const _internal = ctx._internal;
+    // Global and API responses are app-wide: a change an app event makes must
+    // re-render the pages, and reportAppChange has already reported it to them.
+    const updateAppRoot = _internal.update;
+    _internal.update = (options)=>{
+        updateAppRoot(options);
+        Object.values(lowdefy.contexts).forEach((pageContext)=>{
+            pageContext._internal.update({
+                changes: []
+            });
+        });
+    };
+    // Every page mount asks for the app events, and a navigation can mount the
+    // next page before they finish, so each runs once and later callers share it.
+    const runOnInit = _internal.runOnInit;
+    const runOnInitAsync = _internal.runOnInitAsync;
+    let onInitPromise = null;
+    let onInitAsyncPromise = null;
+    _internal.runOnInit = (progress)=>{
+        if (!onInitPromise) {
+            onInitPromise = runOnInit(progress);
+        }
+        return onInitPromise;
+    };
+    _internal.runOnInitAsync = (progress)=>{
+        if (!onInitAsyncPromise) {
+            onInitAsyncPromise = _internal.runOnInit(progress).then(()=>runOnInitAsync(progress));
+        }
+        return onInitAsyncPromise;
+    };
+    lowdefy.appContext = ctx;
+    return ctx;
+}
+export default getAppContext;

package/dist/getContext.js

@@ -13,50 +13,7 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { LowdefyInternalError } from '@lowdefy/errors';
-import { serializer } from '@lowdefy/helpers';
-import { WebParser } from '@lowdefy/operators';
-import Actions from './Actions.js';
-import DependencyTracker from './tracking/DependencyTracker.js';
-import readMediaViewport from './tracking/readMediaViewport.js';
-import Slots from './Slots.js';
-import Requests from './Requests.js';
-import State from './State.js';
-import updateMedia from './tracking/updateMedia.js';
-import WebSockets from './WebSockets.js';
-const blockData = (config)=>{
-    const { slots, blockId, blocks, class: blockClass, events, field, id, layout, loading, pageId, properties, requests, required, skeleton, style, subscriptions, type, validate, visible } = config;
-    const result = {
-        slots,
-        blockId,
-        blocks,
-        class: blockClass,
-        events,
-        field,
-        id,
-        layout,
-        loading,
-        pageId,
-        properties,
-        requests,
-        required,
-        skeleton,
-        style,
-        subscriptions,
-        type,
-        validate,
-        visible
-    };
-    // Preserve ~k (configKey) for error tracing - it's non-enumerable so must be copied explicitly
-    if (config['~k']) {
-        Object.defineProperty(result, '~k', {
-            value: config['~k'],
-            enumerable: false,
-            writable: true,
-            configurable: true
-        });
-    }
-    return result;
-};
+import createContext from './createContext.js';
 function getContext({ config, jsMap = {}, lowdefy, resetContext = {
     reset: false,
     setReset: ()=>undefined
@@ -75,10 +32,6 @@ function getContext({ config, jsMap = {}, lowdefy, resetContext = {
         // memoize context if already created, eg between page transitions, unless the reset flag is
         // raised. A full pass: this render-time update is how changes with no reporting hook reach the
         // page - user, i18n, theme, menus, inputs and the URL.
-        // The pass reads the current viewport, which a resize while the page was away changed.
-        lowdefy.contexts[id]._internal.media = readMediaViewport({
-            lowdefy
-        });
         lowdefy.contexts[id]._internal.update();
         return lowdefy.contexts[id];
     }
@@ -92,92 +45,11 @@ function getContext({ config, jsMap = {}, lowdefy, resetContext = {
     if (!lowdefy.inputs[id]) {
         lowdefy.inputs[id] = {};
     }
-    const ctx = {
-        id,
-        pageId: config.pageId,
-        eventLog: [],
+    const ctx = createContext({
+        config,
         jsMap,
-        requests: {},
-        state: {},
-        _internal: {
-            lowdefy,
-            // Config object reference for dynamic page memoization — identity marks
-            // which fetch this context was built from.
-            pageConfig: config,
-            // The viewport the page's blocks last evaluated _media against, or null without a window.
-            // updateMedia diffs a resize against it.
-            media: readMediaViewport({
-                lowdefy
-            }),
-            // The read recorder of the block evaluating itself, or null. Managed by DependencyTracker.
-            readRecorder: null,
-            rootBlock: blockData(config),
-            update: ()=>{},
-            // React updaters register here per block id when the context's Block
-            // components mount — scoped per context so rebuilding over a live
-            // context (dynamic page navigation, reset) never notifies the previous
-            // context's still-mounted components.
-            updaters: {}
-        }
-    };
-    const _internal = ctx._internal;
-    _internal.DependencyTracker = new DependencyTracker(ctx);
-    _internal.parser = new WebParser({
-        context: ctx,
-        operators: lowdefy._internal.operators
-    });
-    _internal.State = new State(ctx);
-    _internal.Actions = new Actions(ctx);
-    _internal.Requests = new Requests(ctx);
-    _internal.WebSockets = new WebSockets(ctx);
-    _internal.RootSlots = new Slots({
-        slots: {
-            root: {
-                blocks: [
-                    _internal.rootBlock
-                ]
-            }
-        },
-        context: ctx
+        lowdefy
     });
-    _internal.RootSlots.init(serializer.copy(ctx.state));
-    // update({ changes }) is a dependency-tracked pass; a bare update() is a full pass.
-    _internal.update = (options)=>{
-        _internal.RootSlots.update(options);
-    };
-    _internal.runOnInit = async (progress)=>{
-        progress();
-        if (!_internal.onInitDone) {
-            await _internal.RootSlots.slots.root.blocks[0].triggerEvent({
-                name: 'onInit',
-                progress
-            });
-            _internal.update();
-            _internal.State.freezeState();
-            _internal.onInitDone = true;
-        }
-    };
-    _internal.runOnInitAsync = async (progress)=>{
-        if (_internal.onInitDone && !_internal.onInitAsyncDone) {
-            await _internal.RootSlots.slots.root.blocks[0].triggerEvent({
-                name: 'onInitAsync',
-                progress
-            });
-            _internal.onInitAsyncDone = true;
-        }
-    };
-    // Called by the client's debounced resize listener.
-    _internal.updateMedia = ()=>updateMedia({
-            context: ctx
-        });
-    // Page lifecycle events (onVisible, onHidden, onOnline, onOffline, onResize) are
-    // triggered on the page's root block by browser listeners attached in the client.
-    _internal.triggerPageEvent = ({ name, event, progress = ()=>undefined })=>_internal.RootSlots.slots.root.blocks[0].triggerEvent({
-            name,
-            event,
-            progress
-        });
-    ctx._internal.update();
     lowdefy.contexts[id] = ctx;
     return ctx;
 }

package/dist/getDomEvent.js

@@ -0,0 +1,25 @@
+/*
+  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.
+*/ // The DOM event whose listeners are running: window.event is set while a listener runs, including
+// the microtasks that run before the listener returns (React flushes discrete updates and their
+// effects there), and undefined outside a DOM dispatch.
+function getDomEvent() {
+    // The engine's unit tests run without a window.
+    if (typeof window === 'undefined') return null;
+    const domEvent = window.event;
+    if (!(domEvent instanceof Event)) return null;
+    return domEvent;
+}
+export default getDomEvent;

package/dist/getPathIndex.js

@@ -0,0 +1,23 @@
+/*
+  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.
+*/ // The client renders every block inside a layout element with the id `bl-<blockId>`
+// (packages/client/src/block). Its position on the DOM event's path, innermost first, or -1 when
+// the event did not pass through the block.
+function getPathIndex({ blockId, path }) {
+    const element = document.getElementById(`bl-${blockId}`);
+    if (element === null) return -1;
+    return path.indexOf(element);
+}
+export default getPathIndex;

package/dist/index.js

@@ -17,11 +17,12 @@ import Slots from './Slots.js';
 import createLink from './createLink.js';
 import decodeServerError, { getDevError } from './decodeServerError.js';
 import Events from './Events.js';
+import getAppContext from './getAppContext.js';
 import getContext from './getContext.js';
 import getHomePathname from './getHomePathname.js';
 import Requests from './Requests.js';
 import resolveTarget from './resolveTarget.js';
 import State from './State.js';
 import stopChain from './stopChain.js';
-export { Actions, Slots, createLink, decodeServerError, Events, getDevError, getHomePathname, Requests, resolveTarget, State, stopChain };
+export { Actions, Slots, createLink, decodeServerError, Events, getAppContext, getDevError, getHomePathname, Requests, resolveTarget, State, stopChain };
 export default getContext;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lowdefy/engine",
-  "version": "0.0.0-experimental-20260929101721",
+  "version": "0.0.0-experimental-20260929135001",
   "license": "Apache-2.0",
   "description": "",
   "homepage": "https://lowdefy.com",
@@ -30,16 +30,16 @@
     "dist/*"
   ],
   "dependencies": {
-    "@lowdefy/errors": "0.0.0-experimental-20260929101721",
-    "@lowdefy/helpers": "0.0.0-experimental-20260929101721",
-    "@lowdefy/operators": "0.0.0-experimental-20260929101721"
+    "@lowdefy/errors": "0.0.0-experimental-20260929135001",
+    "@lowdefy/helpers": "0.0.0-experimental-20260929135001",
+    "@lowdefy/operators": "0.0.0-experimental-20260929135001"
   },
   "devDependencies": {
     "@jest/globals": "28.1.3",
-    "@lowdefy/actions-core": "0.0.0-experimental-20260929101721",
-    "@lowdefy/build": "0.0.0-experimental-20260929101721",
-    "@lowdefy/operators-js": "0.0.0-experimental-20260929101721",
-    "@lowdefy/operators-mql": "0.0.0-experimental-20260929101721",
+    "@lowdefy/actions-core": "0.0.0-experimental-20260929135001",
+    "@lowdefy/build": "0.0.0-experimental-20260929135001",
+    "@lowdefy/operators-js": "0.0.0-experimental-20260929135001",
+    "@lowdefy/operators-mql": "0.0.0-experimental-20260929135001",
     "@swc/cli": "0.8.1",
     "@swc/core": "1.15.32",
     "@swc/jest": "0.2.39",