@lowdefy/api 6.0.0 → 6.1.0

package/dist/routes/endpoints/control/controlTry.js

@@ -12,7 +12,8 @@
   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 runRoutine from '../runRoutine.js';
+*/ import { projectCaughtError } from '@lowdefy/helpers';
+import runRoutine from '../runRoutine.js';
 async function controlTry(context, routineContext, { control }) {
     context.logger.debug({
         event: 'debug_control_try'
@@ -20,15 +21,24 @@ async function controlTry(context, routineContext, { control }) {
     let res = await runRoutine(context, routineContext, {
         routine: control[':try']
     });
-    if (res.status === 'error') {
-        if (control[':catch']) {
-            context.logger.debug({
-                event: 'debug_control_catch'
-            });
-            res = await runRoutine(context, routineContext, {
-                routine: control[':catch']
-            });
-        }
+    if (res.status === 'error' && control[':catch']) {
+        context.logger.debug({
+            event: 'debug_control_catch'
+        });
+        // A child context rather than a field set on routineContext: the same object is handed to
+        // :try, :finally and every :parallel branch, so writing to it would let an inner :try clobber
+        // the outer catch's error and parallel branches read each other's. steps and state are still
+        // shared because routines mutate them in place. The projection is built once here, never the
+        // raw error, so no operator in the catch can read its received value or source.
+        const error = projectCaughtError(res.error, {
+            scrub: context.scrubSecrets
+        });
+        res = await runRoutine(context, {
+            ...routineContext,
+            error
+        }, {
+            routine: control[':catch']
+        });
     }
     if (control[':finally']) {
         context.logger.debug({

package/dist/routes/endpoints/evaluateRoutineOperators.js

@@ -0,0 +1,26 @@
+/*
+  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 operatorScope from './operatorScope.js';
+// Every routine step evaluates against the same frame. Taking the frame from routineContext in one
+// place means a step handler cannot drop part of it (state, items, loop indices).
+function evaluateRoutineOperators(context, routineContext, { input, location }) {
+    return context.evaluateOperators({
+        arrayIndices: routineContext.arrayIndices,
+        input,
+        location,
+        ...operatorScope(routineContext)
+    });
+}
+export default evaluateRoutineOperators;

package/dist/routes/endpoints/forwardScheduledEndpoint.js

@@ -18,29 +18,34 @@ import findSchedule from './findSchedule.js';
 import getEndpointConfig from './getEndpointConfig.js';
 import getEnvironmentSchedules from './getEnvironmentSchedules.js';
 import scheduleBackground from './scheduleBackground.js';
-// Vercel fires cron jobs only on the production deployment, so the schedules of every other
-// environment are registered there as /api/cron-forward/<environment>/<endpointId> jobs. When one
-// fires, this pings the environment's own /api/cron/<endpointId> with that environment's
-// CRON_SECRET (a Lowdefy secret named in config.cron.environments) so the environment runs its own
-// code, and answers Vercel immediately: the ping is fire-and-forget, kept alive by scheduleBackground
-// and bounded by the function duration, and its outcome exists only in the logs.
+// Vercel fires cron jobs only on the production deployment, so the schedules of every environment
+// with a cron.secret are registered there as /api/cron-forward/<environment>/<endpointId> jobs. When
+// one fires, this pings the environment's own /api/cron/<endpointId> at its url with that
+// environment's CRON_SECRET (the Lowdefy secret named by config.environments.<env>.cron.secret) so
+// the environment runs its own code, and answers Vercel immediately: the ping is fire-and-forget,
+// kept alive by scheduleBackground and bounded by the function duration, and its outcome exists only
+// in the logs.
 async function forwardScheduledEndpoint(context, { environment, endpointId, cron }) {
     const { config, logger, secrets } = context;
-    const target = config?.cron?.environments?.[environment];
+    const target = config?.environments?.[environment];
     if (!type.isObject(target)) {
-        throw new ConfigError(`Cron environment "${environment}" is not declared in lowdefy.config.cron.environments.`);
+        throw new ConfigError(`Cron environment "${environment}" is not declared in config.environments.`);
     }
-    if (type.isUndefined(target.url)) {
-        throw new ConfigError(`Cron environment "${environment}" has no url to forward to: it is the environment that runs the crons.`);
+    if (environment === config.environment) {
+        throw new ConfigError(`Cron environment "${environment}" is this deployment's own environment: its crons run here, not forwarded.`);
     }
-    if (target.enabled === false) {
+    if (target.cron?.enabled === false) {
         throw new ConfigError(`Cron environment "${environment}" is disabled.`);
     }
-    const secret = secrets?.[target.secret];
+    const secretName = target.cron?.secret;
+    if (type.isUndefined(secretName)) {
+        throw new ConfigError(`Cron environment "${environment}" has no cron.secret: crons are only forwarded to environments with one.`);
+    }
+    const secret = secrets?.[secretName];
     if (!type.isString(secret) || secret === '') {
-        throw new ConfigError(`Secret "${target.secret}" holding the CRON_SECRET of cron environment "${environment}" is not set. Set the LOWDEFY_SECRET_${target.secret} environment variable on this deployment.`);
+        throw new ConfigError(`Secret "${secretName}" holding the CRON_SECRET of cron environment "${environment}" is not set. Set the LOWDEFY_SECRET_${secretName} environment variable on this deployment.`);
     }
-    // The same build is deployed to every environment, so the local artifact says whether the target
+    // Every environment builds from the same config, so the local artifact says whether the target
     // declares the firing schedule: fail here with a config error instead of having the target 500.
     const endpointConfig = await getEndpointConfig(context, {
         endpointId

package/dist/routes/endpoints/getEnvironmentSchedules.js

@@ -13,17 +13,15 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { type } from '@lowdefy/helpers';
-// With config.cron.environments declared the build resolves `schedules` onto every environment
-// (schedules.<name>, defaults inherited), so an environment run reads its own list; without
-// environments the endpoint carries a plain array.
+// With config.environments declared the build resolves `schedules` onto every environment
+// (schedules.<name>, defaults inherited, plus schedules.default), so an environment run reads its
+// own list and a deployment with no current environment reads the default; without environments
+// the endpoint carries a plain array.
 function getEnvironmentSchedules({ endpointConfig, environment }) {
     const schedules = endpointConfig.schedules;
     if (type.isArray(schedules)) {
         return schedules;
     }
-    if (environment === undefined) {
-        return [];
-    }
-    return schedules?.[environment] ?? [];
+    return schedules?.[environment ?? 'default'] ?? [];
 }
 export default getEnvironmentSchedules;

package/dist/routes/endpoints/handleAgentCall.js

@@ -16,20 +16,17 @@
 import { type } from '@lowdefy/helpers';
 import addStepResult from './addStepResult.js';
 import prepareAgent from '../agent/prepareAgent.js';
+import evaluateRoutineOperators from './evaluateRoutineOperators.js';
 async function handleAgentCall(context, routineContext, { step }) {
-    const { logger, evaluateOperators } = context;
+    const { logger } = context;
     logger.debug({
         event: 'debug_start_agent_call',
         step
     });
     // Evaluate operators in step.properties (resolves agentId, prompt)
-    const evaluatedProperties = evaluateOperators({
+    const evaluatedProperties = evaluateRoutineOperators(context, routineContext, {
         input: step.properties,
-        items: routineContext.items,
-        location: step.stepId,
-        payload: routineContext.payload,
-        state: routineContext.state,
-        steps: routineContext.steps
+        location: step.stepId
     });
     const { agentId, prompt } = evaluatedProperties;
     if (!type.isString(agentId)) {

package/dist/routes/endpoints/handleEndpointCall.js

@@ -17,20 +17,17 @@ import { ConfigError } from '@lowdefy/errors';
 import addStepResult from './addStepResult.js';
 import invokeEndpoint from './invokeEndpoint.js';
 import scheduleBackground from './scheduleBackground.js';
+import evaluateRoutineOperators from './evaluateRoutineOperators.js';
 async function handleEndpointCall(context, routineContext, { step }) {
-    const { logger, evaluateOperators } = context;
+    const { logger } = context;
     logger.debug({
         event: 'debug_start_endpoint_call',
         step
     });
     // Evaluate operators in step.properties (resolves endpointId, payload)
-    const evaluatedProperties = evaluateOperators({
+    const evaluatedProperties = evaluateRoutineOperators(context, routineContext, {
         input: step.properties,
-        items: routineContext.items,
-        location: step.stepId,
-        payload: routineContext.payload,
-        state: routineContext.state,
-        steps: routineContext.steps
+        location: step.stepId
     });
     // detached: true — fire-and-forget the call back through the deployment's
     // /api/detached route, so the target runs in its OWN function invocation

package/dist/routes/endpoints/handleRenderNotification.js

@@ -16,10 +16,12 @@
 import { ConfigError } from '@lowdefy/errors';
 import { type } from '@lowdefy/helpers';
 import addStepResult from './addStepResult.js';
+import getCurrentEnvironment from '../../context/getCurrentEnvironment.js';
 import derivePreview from '../notifications/derivePreview.js';
 import getNotificationConfig from '../notifications/getNotificationConfig.js';
 import resolveNotificationLinks from '../notifications/resolveNotificationLinks.js';
 import resolveThemeLogo from '../notifications/resolveThemeLogo.js';
+import evaluateRoutineOperators from './evaluateRoutineOperators.js';
 function itemHasPageLinks(item, dataKeys) {
     const links = Object.values(item.links ?? {});
     const arrayLinks = dataKeys.flatMap((key)=>(type.isArray(item[key]) ? item[key] : []).map((entry)=>entry?.link));
@@ -29,18 +31,14 @@ function itemHasPageLinks(item, dataKeys) {
     ].some((link)=>type.isObject(link) && !type.isNone(link.pageId));
 }
 async function handleRenderNotification(context, routineContext, { step }) {
-    const { logger, evaluateOperators } = context;
+    const { logger } = context;
     logger.debug({
         event: 'debug_start_render_notification',
         step
     });
-    const evaluatedProperties = evaluateOperators({
+    const evaluatedProperties = evaluateRoutineOperators(context, routineContext, {
         input: step.properties,
-        items: routineContext.items,
-        location: step.stepId,
-        payload: routineContext.payload,
-        state: routineContext.state,
-        steps: routineContext.steps
+        location: step.stepId
     });
     const { notificationId, data, landingPage, recordId } = evaluatedProperties;
     let { serverUrl } = evaluatedProperties;
@@ -65,6 +63,15 @@ async function handleRenderNotification(context, routineContext, { step }) {
                 configKey: step['~k']
             });
         }
+    } else {
+        // The current environment's url is the deployment origin, so links need no per-step wiring.
+        // On the dev server the request origin is the local app; in production it is never used, since
+        // a spoofed Host header would then steer the links in outgoing mail.
+        serverUrl = getCurrentEnvironment({
+            config: context.config
+        })?.url ?? (context.dev === true ? context.origin : undefined);
+    }
+    if (!type.isNone(serverUrl)) {
         serverUrl = serverUrl.replace(/\/$/, '');
     }
     if (!type.isNone(landingPage) && !type.isString(landingPage)) {
@@ -111,7 +118,7 @@ async function handleRenderNotification(context, routineContext, { step }) {
     });
     if (itemHasPageLinks(data, Template.dataKeys ?? [])) {
         if (type.isNone(serverUrl)) {
-            throw new ConfigError(`Notification "${notificationId}" has links but no server URL is available. Set the serverUrl step property.`, {
+            throw new ConfigError(`Notification "${notificationId}" has links but no server URL is available. Set the serverUrl step property, or the url of the current environment in config.environments.`, {
                 configKey: step['~k']
             });
         }

package/dist/routes/endpoints/handleRequest.js

@@ -23,7 +23,6 @@ import getRequestResolver from '../request/getRequestResolver.js';
 import validateSchemas from '../request/validateSchemas.js';
 async function handleRequest(context, routineContext, { request }) {
     const { logger } = context;
-    const { items } = routineContext;
     logger.debug({
         event: 'debug_start_request',
         request
@@ -42,11 +41,8 @@ async function handleRequest(context, routineContext, { request }) {
     });
     const { connectionProperties, requestProperties } = evaluateOperators(context, {
         connectionConfig,
-        items,
-        payload: routineContext.payload,
         requestConfig,
-        state: routineContext.state,
-        steps: routineContext.steps
+        routineContext
     });
     checkConnectionRead(context, {
         connectionConfig,

package/dist/routes/endpoints/handleValidateSchema.js

@@ -13,7 +13,9 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { validate } from '@lowdefy/ajv';
+import { UserError } from '@lowdefy/errors';
 import addStepResult from './addStepResult.js';
+import evaluateRoutineOperators from './evaluateRoutineOperators.js';
 function buildErrorMessage(errors, stepId) {
     const first = errors?.[0];
     if (!first) return `ValidateSchema step "${stepId}" failed.`;
@@ -21,17 +23,14 @@ function buildErrorMessage(errors, stepId) {
     return `ValidateSchema step "${stepId}" failed at ${path}: ${first.message}.`;
 }
 async function handleValidateSchema(context, routineContext, { step }) {
-    const { logger, evaluateOperators } = context;
+    const { logger } = context;
     logger.debug({
         event: 'debug_start_validate_schema',
         step
     });
-    const evaluatedProperties = evaluateOperators({
+    const evaluatedProperties = evaluateRoutineOperators(context, routineContext, {
         input: step.properties,
-        items: routineContext.items,
-        location: step.stepId,
-        payload: routineContext.payload,
-        steps: routineContext.steps
+        location: step.stepId
     });
     const { schema, data, throwOnInvalid = true } = evaluatedProperties;
     const { valid, errors } = validate({
@@ -48,15 +47,18 @@ async function handleValidateSchema(context, routineContext, { step }) {
         stepId: step.stepId
     });
     if (!valid && throwOnInvalid) {
-        const error = new Error(buildErrorMessage(result.errors, step.stepId), {
-            cause: result.errors
-        });
+        // A UserError, so the caller sees which field failed: the message is built from the schema
+        // path and rule, never the data, and every other server error reaches the client generic.
+        // No cause: a UserError's cause crosses the wire as author data, and the ajv errors carry
+        // server schema detail. They stay in the step result and the log.
+        const error = new UserError(buildErrorMessage(result.errors, step.stepId));
         // Log under `err` — see controlThrow: only the `err` key runs the pino error
         // serializer, so `error` would drop the message from the log line.
         logger.error({
             event: 'error_validate_schema',
             stepId: step.stepId,
-            err: error
+            err: error,
+            errors: result.errors
         });
         return {
             status: 'error',

package/dist/routes/endpoints/invokeEndpoint.js

@@ -30,6 +30,7 @@ async function invokeEndpoint(context, { endpointId, payload, endpointDepth }) {
         steps: {},
         payload: payload ?? {},
         arrayIndices: [],
+        error: null,
         items: {},
         state: {},
         endpointDepth: endpointDepth + 1

package/dist/routes/endpoints/operatorScope.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.
+*/ // The routine fields operators can read. A field added to the routine frame goes here, so every
+// routine step and control sees it rather than only the ones that remembered to pass it.
+function operatorScope(routineContext) {
+    const { error, items, payload, state, steps } = routineContext;
+    return {
+        error: error ?? null,
+        items,
+        payload,
+        state,
+        steps
+    };
+}
+export default operatorScope;

package/dist/routes/endpoints/resolveCronEnvironment.js

@@ -16,22 +16,23 @@
 import { ConfigError } from '@lowdefy/errors';
 // The environment a cron run resolves its schedules for. A forwarded request names it in the
 // x-lowdefy-cron-environment header; a request without one is the deployment running its own crons,
-// which is the environment declared without a url (the one Vercel fires crons on). Without
-// config.cron there are no environments and the endpoint's plain schedules apply.
+// which is the current environment (config.environment). Without config.environments there are no
+// environments and the endpoint's plain schedules apply; without a current environment the
+// `default` schedules apply.
 function resolveCronEnvironment({ config, environment }) {
-    const environments = config?.cron?.environments;
+    const environments = config?.environments;
     if (type.isNone(environments)) {
         if (!type.isNone(environment)) {
-            throw new ConfigError(`Cron environment "${environment}" is not configured: lowdefy.config.cron.environments is not defined.`);
+            throw new ConfigError(`Cron environment "${environment}" is not configured: config.environments is not defined.`);
         }
         return undefined;
     }
     if (!type.isNone(environment)) {
         if (!type.isObject(environments[environment])) {
-            throw new ConfigError(`Cron environment "${environment}" is not declared in lowdefy.config.cron.environments.`);
+            throw new ConfigError(`Cron environment "${environment}" is not declared in config.environments.`);
         }
         return environment;
     }
-    return Object.keys(environments).find((name)=>type.isObject(environments[name]) && type.isUndefined(environments[name].url));
+    return config.environment;
 }
 export default resolveCronEnvironment;

package/dist/routes/endpoints/runDetachedEndpoint.js

@@ -50,6 +50,7 @@ async function runDetachedEndpoint(context, { endpointId, payload }) {
         steps: {},
         payload: serializer.deserialize(payload ?? {}),
         arrayIndices: [],
+        error: null,
         items: {},
         state: {},
         endpointDepth: 0

package/dist/routes/endpoints/runScheduledEndpoint.js

@@ -70,6 +70,7 @@ async function runScheduledEndpoint(context, { endpointId, cron, environment })
         steps: {},
         payload: schedule.payload ?? {},
         arrayIndices: [],
+        error: null,
         items: {},
         state: {},
         endpointDepth: 0

package/dist/routes/endpoints/runWebhookEndpoint.js

@@ -67,6 +67,7 @@ async function runWebhookEndpoint(context, { endpointId, body, query, headers })
             headers: headers ?? {}
         },
         arrayIndices: [],
+        error: null,
         items: {},
         state: {},
         endpointDepth: 0

package/dist/routes/endpoints/test/runTest.js

@@ -1,4 +1,18 @@
-import { jest } from '@jest/globals';
+/*
+  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 { jest } from '@jest/globals';
 import { wait } from '@lowdefy/helpers';
 import { operatorsServer } from '@lowdefy/operators-js';
 import createEvaluateOperators from '../../../context/createEvaluateOperators.js';
@@ -7,7 +21,7 @@ import testContext from '../../../test/testContext.js';
 // const { _date, _eq, _payload, _secret, _user } = operatorsServer;
 const operators = {
     ...operatorsServer,
-    _error: ()=>{
+    _throw_test: ()=>{
         throw new Error('Test error.');
     }
 };
@@ -89,6 +103,7 @@ async function runTest({ routine, payload = {} }) {
     const routineContext = {
         steps: {},
         payload,
+        error: null,
         items: {},
         arrayIndices: [],
         state: {},

package/dist/routes/mcp/createMcpServer.js

@@ -17,6 +17,7 @@ import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprot
 import { AuthenticationError } from '@lowdefy/errors';
 import { serializer, type } from '@lowdefy/helpers';
 import callEndpoint from '../endpoints/callEndpoint.js';
+import createWireProjection from '../../response/createWireProjection.js';
 import isUnauthenticatedHuman from '../endpoints/isUnauthenticatedHuman.js';
 // LLM-safe tool names use the same rule as buildAgents tool naming.
 function toToolName(id) {
@@ -102,11 +103,25 @@ async function createMcpServer({ context }) {
                 });
                 if (!success) {
                     const deserialized = serializer.deserialize(error);
+                    let text = deserialized?.message ?? 'Endpoint failed.';
+                    // The dev MCP route serves a coding agent, which is a dev tool: it gets the real
+                    // message and the config location so it can go straight to the YAML. A prod MCP
+                    // client is an end-user reader and keeps the wire message.
+                    if (context.mode === 'dev' && !type.isNone(error?.devError)) {
+                        const devError = serializer.deserialize(error.devError);
+                        text = devError.message;
+                        if (!type.isNone(devError.source)) {
+                            text = `${text} (at ${devError.source})`;
+                        }
+                        if (!type.isNone(devError.hint)) {
+                            text = `${text} Hint: ${devError.hint}`;
+                        }
+                    }
                     return {
                         content: [
                             {
                                 type: 'text',
-                                text: deserialized?.message ?? 'Endpoint failed.'
+                                text
                             }
                         ],
                         isError: true
@@ -144,11 +159,14 @@ async function createMcpServer({ context }) {
             } else {
                 context.logger.error(error);
             }
+            // This error never went through an endpoint result, so it has not been projected yet.
+            // The projection keeps an AuthenticationError's message.
+            const text = context.mode === 'dev' ? error.message : createWireProjection(context)(error).message;
             return {
                 content: [
                     {
                         type: 'text',
-                        text: error.message
+                        text
                     }
                 ],
                 isError: true

package/dist/routes/request/callRequest.js

@@ -59,10 +59,16 @@ async function callRequest(context, { blockId, pageId, payload, requestId }) {
     });
     const { connectionProperties, requestProperties } = evaluateOperators(context, {
         connectionConfig,
-        payload: requestPayload,
         requestConfig,
-        state: {},
-        steps: {}
+        // A page request runs outside any routine, so it evaluates against an empty frame.
+        routineContext: {
+            arrayIndices: [],
+            error: null,
+            items: {},
+            payload: requestPayload,
+            state: {},
+            steps: {}
+        }
     });
     checkConnectionRead(context, {
         connectionConfig,

package/dist/routes/request/callRequestResolver.js

@@ -13,6 +13,7 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { RequestError, ServiceError } from '@lowdefy/errors';
+import getCurrentEnvironment from '../../context/getCurrentEnvironment.js';
 import invokeEndpoint from '../endpoints/invokeEndpoint.js';
 async function callRequestResolver(context, { connectionProperties, endpointDepth, requestConfig, requestProperties, requestResolver }) {
     const { blockId, endpointId, logger, pageId, payload } = context;
@@ -49,6 +50,11 @@ async function callRequestResolver(context, { connectionProperties, endpointDept
             connection: connectionProperties,
             connectionId: requestConfig.connectionId,
             endpointId,
+            // The deployment's current environment ({ name, url, email, ... }) or null, so connection
+            // types can apply environment settings such as the email delivery filter.
+            environment: getCurrentEnvironment({
+                config: context.config
+            }),
             pageId,
             payload,
             request: requestProperties,

package/dist/routes/request/evaluateOperators.js

@@ -12,21 +12,17 @@
   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.
-*/ function evaluateOperators({ evaluateOperators }, { connectionConfig, items, payload, requestConfig, state, steps }) {
-    const connectionProperties = evaluateOperators({
+*/ import evaluateRoutineOperators from '../endpoints/evaluateRoutineOperators.js';
+// Connection and request properties evaluate against the same frame, so `_item` in a connection's
+// properties resolves inside a `:for` loop just like it does in the request's.
+function evaluateOperators(context, { connectionConfig, requestConfig, routineContext }) {
+    const connectionProperties = evaluateRoutineOperators(context, routineContext, {
         input: connectionConfig.properties || {},
-        location: connectionConfig.connectionId,
-        payload,
-        state,
-        steps
+        location: connectionConfig.connectionId
     });
-    const requestProperties = evaluateOperators({
+    const requestProperties = evaluateRoutineOperators(context, routineContext, {
         input: requestConfig.properties || {},
-        items,
-        location: requestConfig.stepId ?? requestConfig.requestId,
-        payload,
-        state,
-        steps
+        location: requestConfig.stepId ?? requestConfig.requestId
     });
     return {
         connectionProperties,

package/dist/routes/websocket/createChannelRegistry.js

@@ -15,6 +15,7 @@
 */ import crypto from 'crypto';
 import { serializer } from '@lowdefy/helpers';
 import { ConfigError, PluginError, ServiceError } from '@lowdefy/errors';
+import createWireProjection from '../../response/createWireProjection.js';
 import prepareChannel from './prepareChannel.js';
 const MAX_RETRIES = 5;
 const RETRY_BASE_MS = 1000;
@@ -39,6 +40,23 @@ function createChannelRegistry() {
             subscriber.send(message);
         });
     }
+    // Config reads a broadcast error only as a message string, so it gets the wire
+    // message alone - no requestId, since no single request raised it, and no
+    // devError, since the dev terminal already logs it in full. The channel's
+    // context belongs to whoever subscribed first, so the message is translated
+    // with each subscriber's own locale.
+    function broadcastError(channel, error) {
+        channel.subscribers.forEach((subscriber)=>{
+            const { message } = createWireProjection({
+                i18n: subscriber.i18n
+            })(error);
+            subscriber.send(JSON.stringify({
+                type: 'error',
+                websocketId: channel.websocketId,
+                message
+            }));
+        });
+    }
     function wrapResolverError({ channel, error }) {
         if (!error.configKey) {
             error.configKey = channel.websocketConfig['~k'];
@@ -86,11 +104,7 @@ function createChannelRegistry() {
             err: wrapped
         }, wrapped.message);
         channel.context.handleError(wrapped);
-        broadcast(channel, {
-            type: 'error',
-            websocketId: channel.websocketId,
-            message: wrapped.message
-        });
+        broadcastError(channel, wrapped);
         // A run that stayed healthy resets the backoff window.
         if (Date.now() - startedAt > HEALTHY_RESET_MS) {
             channel.retryCount = 0;