@lowdefy/api 6.0.0 → 6.1.0

package/dist/context/createEvaluateOperators.js

@@ -23,8 +23,10 @@ function createEvaluateOperators(context) {
         secrets,
         user
     });
-    function evaluateOperators({ input, items, location, payload, state, steps }) {
+    function evaluateOperators({ arrayIndices, error, input, items, location, payload, state, steps }) {
         const { output, errors } = operatorsParser.parse({
+            arrayIndices,
+            error,
             input,
             items,
             location,

package/dist/context/getCurrentEnvironment.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 environment this deployment is, resolved by the build from LOWDEFY_ENVIRONMENT into
+// config.environment and config.environments. Null when no current environment is set or when it
+// is not declared, so callers fall back to their own defaults.
+function getCurrentEnvironment({ config }) {
+    const name = config?.environment;
+    const settings = config?.environments?.[name];
+    if (settings === undefined) return null;
+    return {
+        ...settings,
+        name
+    };
+}
+export default getCurrentEnvironment;

package/dist/index.js

@@ -21,6 +21,7 @@ import createApiContext from './context/createApiContext.js';
 import createChannelRegistry from './routes/websocket/createChannelRegistry.js';
 import createMcpServer from './routes/mcp/createMcpServer.js';
 import createWebSocketConnection from './routes/websocket/createWebSocketConnection.js';
+import createWireProjection from './response/createWireProjection.js';
 import createSessionCallback from './routes/auth/callbacks/createSessionCallback.js';
 import getAuthConfig from './routes/auth/getAuthConfig.js';
 import getAuthStrategies from './routes/auth/strategies/getAuthStrategies.js';
@@ -35,4 +36,4 @@ import forwardScheduledEndpoint from './routes/endpoints/forwardScheduledEndpoin
 import runDetachedEndpoint from './routes/endpoints/runDetachedEndpoint.js';
 import runWebhookEndpoint from './routes/endpoints/runWebhookEndpoint.js';
 import runScheduledEndpoint from './routes/endpoints/runScheduledEndpoint.js';
-export { buildEndpointResult, callAgent, callEndpoint, getEndpointConfig, callRequest, createApiContext, createChannelRegistry, createMcpServer, createSessionCallback, createWebSocketConnection, getAuthConfig, getAuthStrategies, getHomeAndMenus, getPageConfig, getRootConfig, logClientError, redactErrorResponse, redactResponse, resolveStrategyCaller, forwardScheduledEndpoint, runDetachedEndpoint, runWebhookEndpoint, runScheduledEndpoint };
+export { buildEndpointResult, callAgent, callEndpoint, getEndpointConfig, callRequest, createApiContext, createChannelRegistry, createMcpServer, createSessionCallback, createWebSocketConnection, createWireProjection, getAuthConfig, getAuthStrategies, getHomeAndMenus, getPageConfig, getRootConfig, logClientError, redactErrorResponse, redactResponse, resolveStrategyCaller, forwardScheduledEndpoint, runDetachedEndpoint, runWebhookEndpoint, runScheduledEndpoint };

package/dist/response/buildEndpointResult.js

@@ -17,7 +17,9 @@ import redactResponse from './redactResponse.js';
 // The wire object every endpoint route returns after running its routine. One
 // function rather than a copy of the same return statement per route, so the
 // `response` field cannot end up policed differently from the `error` field beside
-// it - see redactResponse for why the response needs the policy at all.
+// it - see redactResponse for why the response needs the policy at all. `error` is
+// redactErrorResponse's error payload, so in dev it carries `devError`; `response`
+// never does.
 function buildEndpointResult(context, { error, response, status }) {
     const success = ![
         'error',

package/dist/response/createWireProjection.js

@@ -0,0 +1,88 @@
+/*
+  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 { lowdefyErrorNames, readErrorCodes } from '@lowdefy/errors';
+import { translate } from '@lowdefy/helpers';
+// The framework writes these messages to reveal nothing, and clients branch on
+// them, so they keep their text where every other non-author error does not.
+const AUTH_REFUSAL_NAMES = new Set([
+    'AuthenticationError',
+    'AuthorizationError',
+    'TwoFactorEnrolmentRequiredError'
+]);
+// The client-bound error policy, as an allowlist. Passed to serializer.serialize
+// as `projectError`, so it runs at every error node the walk emits - the cause
+// chain, an Error-valued own property, an Error nested in a response value - and
+// cannot become depth-limited.
+//
+// Only the author's message crosses. A library's message embeds whatever the
+// library saw - URLs with credentials, SQL, hostnames - so every other error
+// becomes one translated generic message plus the fields client config branches
+// on. The full error stays in the server log, and in dev reaches the developer
+// through `devError`, which config never reads.
+//
+// The context is optional: a websocket broadcast has no single request, so it
+// passes no `rid`, and the server error handler can run before any request
+// context exists.
+function createWireProjection(context) {
+    const requestId = context?.rid;
+    const genericMessage = translate({
+        key: 'server.genericError',
+        i18n: context?.i18n
+    });
+    return function project(err) {
+        // A PluginError defaults configKey to null; the walk only drops undefined.
+        const configKey = err.configKey ?? undefined;
+        // Keyed on the name rather than instanceof: the error may come from another
+        // copy of @lowdefy/errors or from a serializer round trip, where the class
+        // identity is gone but the name survives. The cause is returned raw so the
+        // walk projects it too - an Error cause takes the generic shape, and a
+        // non-Error cause is author data cleaned as a value.
+        if (err.name === 'UserError') {
+            return {
+                name: err.name,
+                message: err.message,
+                cause: err.cause,
+                metaData: err.metaData,
+                blockId: err.blockId,
+                pageId: err.pageId,
+                isReject: err.isReject,
+                configKey,
+                // Not read from the node: a caught error rebuilt for `_error` keeps only
+                // its class, and without the flag the client wraps a rethrown UserError
+                // in an ActionError and reports it back to the server a second time.
+                isLowdefyError: true,
+                handled: err.handled,
+                requestId
+            };
+        }
+        const { code, statusCode } = readErrorCodes(err);
+        return {
+            // A foreign class name can itself say which library or driver failed.
+            name: lowdefyErrorNames.has(err.name) ? err.name : 'Error',
+            message: AUTH_REFUSAL_NAMES.has(err.name) ? err.message : genericMessage,
+            code,
+            statusCode,
+            configKey,
+            requestId,
+            // The client revives errors without running a constructor, so this flag
+            // exists there only if the wire carries it. Without it the action runner
+            // wraps the error in a new ActionError without `handled`, POSTs it back to
+            // /api/client-error, and the server logs and reports it a second time.
+            isLowdefyError: true,
+            handled: err.handled
+        };
+    };
+}
+export default createWireProjection;

package/dist/response/normalizeErrorSources.js

@@ -16,13 +16,12 @@
 import { type } from '@lowdefy/helpers';
 // extractErrorProps emits a nested error as a plain props object, not as a second
 // '~e' wrapper, so an error node is recognised by its shape. Keying on the shape
-// rather than on a map of where errors can appear is deliberate: re-deriving those
-// positions is the mistake the walk-level omit exists to avoid, and this predicate
-// still visits every position.
+// rather than on a map of where errors can appear means every position is visited
+// without re-deriving where the walk puts errors.
 //
-// The check matters because the payload also carries author-written data the policy
-// deliberately preserves - a UserError's non-Error cause, its metaData - and a
-// `source` key inside those belongs to the app, not to us.
+// The check matters because the payload also carries author-written data - a
+// UserError's non-Error cause, its metaData - and a `source` key inside those
+// belongs to the app, not to us.
 function isErrorNode(value) {
     return type.isString(value.name) && type.isString(value.message);
 }
@@ -43,17 +42,15 @@ function stripConfigDirectory(value, prefix) {
     }
     Object.values(value).forEach((child)=>stripConfigDirectory(child, prefix));
 }
-// Guarantees `source` reaches a client config-relative, never as an absolute server
-// path. resolveConfigLocation makes it absolute whenever the context carries a
-// configDirectory - server-dev and server-e2e do, and production happens not to
-// today by omission rather than by invariant, which is the drift this closes.
+// Makes `source` in the dev-only `devError` config-relative, never an absolute
+// server path, so the dev tools show the path the developer knows. The wire error
+// carries no `source` at all. resolveConfigLocation makes it absolute whenever the
+// context carries a configDirectory, which server-dev does.
 //
 // A rewrite rather than an omission, and it needs the context, so it runs as a pass
 // over the serialized payload instead of inside the walk.
 function normalizeErrorSources(context, payload) {
-    // errorHandler has an else branch for requests with no lowdefyContext, so a
-    // missing context is a supported call - it only means no source to normalise.
-    const configDirectory = context?.configDirectory;
+    const configDirectory = context.configDirectory;
     if (type.isNone(configDirectory)) return payload;
     // configDirectory is `LOWDEFY_DIRECTORY_CONFIG || process.cwd()` at every site
     // that sets it, so it may be relative or carry a trailing separator, while

package/dist/response/redactErrorResponse.js

@@ -13,18 +13,52 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { serializer, type } from '@lowdefy/helpers';
+import createWireProjection from './createWireProjection.js';
 import normalizeErrorSources from './normalizeErrorSources.js';
-import omitErrorProps from './omitErrorProps.js';
-// Owns the serialization as well as the policy, so the policy cannot be forgotten:
-// no bare serializer.serialize(error) is left in response position to wrap. Every
-// route returning an error to a caller - any status, any transport - goes through
-// here or through buildEndpointResult.
+// The one error payload every route and transport sends for a thrown error, at
+// any status. Owning the serialization as well as the policy leaves no bare
+// serializer.serialize(error) in response position for a caller to forget.
+//
+// `~e` is the wire error - identical in dev and prod, because it is what app
+// config reads. In dev the payload also carries `devError`, the error as the dev
+// terminal logs it, for the dev tools. It sits beside `~e` rather than inside it:
+// the serializer's reviver replaces any object holding `~e` with its error, so a
+// plain deserialize of the payload drops `devError` and config never sees it.
+//
+// `received` is left out of devError at every node: on the request path it is
+// the evaluated request properties, resolved _secret values included, and the
+// dev server can be reached over a LAN or tunnel. The terminal still logs it.
+function projectDevError(err) {
+    const props = {
+        message: err.message,
+        name: err.name,
+        stack: err.stack,
+        cause: err.cause,
+        ...err
+    };
+    delete props.received;
+    return props;
+}
 function redactErrorResponse(context, error) {
     // Endpoint routes serialize the error field on success too, where it is null.
     // Passing that through unchanged keeps them from emitting an empty {'~e'}.
     if (type.isNone(error)) return error;
-    return normalizeErrorSources(context, serializer.serialize(error, {
-        omitErrorProps
-    }));
+    const payload = serializer.serialize(error, {
+        projectError: createWireProjection(context)
+    });
+    // The server error handler has no request context when it fails before the
+    // context middleware runs, so there is no mode to read and no devError.
+    if (context?.mode === 'dev') {
+        const full = serializer.serialize(error, {
+            projectError: projectDevError
+        });
+        payload.devError = normalizeErrorSources(context, {
+            '~e': {
+                ...full['~e'],
+                requestId: context.rid
+            }
+        });
+    }
+    return payload;
 }
 export default redactErrorResponse;

package/dist/response/redactResponse.js

@@ -13,19 +13,19 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { serializer } from '@lowdefy/helpers';
-import normalizeErrorSources from './normalizeErrorSources.js';
-import omitErrorProps from './omitErrorProps.js';
+import createWireProjection from './createWireProjection.js';
 // The response-value call shape, beside redactErrorResponse's error-only one.
 // A response is not an error, but makeReplacer wraps any Error it meets anywhere
-// in a value, so a response holding one is an error-serialization site too - the
-// grep that enumerated those sites could not see them, which is why this exists
-// as a function rather than as a rule to remember.
+// in a value, so a response holding one is an error-serialization site too - a
+// grep for serialize(error) cannot see those sites, which is why this exists as
+// a function rather than as a rule to remember.
 //
-// Same policy as the error field, because it reaches the same audience: a browser
-// for a request or endpoint body, a third party for cron and detached.
+// Same wire projection as the error field, because it reaches the same audience.
+// No devError, in any mode: an Error in a response value is data the routine
+// returned, not a failure of this request.
 function redactResponse(context, response) {
-    return normalizeErrorSources(context, serializer.serialize(response, {
-        omitErrorProps
-    }));
+    return serializer.serialize(response, {
+        projectError: createWireProjection(context)
+    });
 }
 export default redactResponse;

package/dist/routes/agent/prepareAgent.js

@@ -14,6 +14,7 @@
   limitations under the License.
 */ import { type } from '@lowdefy/helpers';
 import buildEndpointResult from '../../response/buildEndpointResult.js';
+import createWireProjection from '../../response/createWireProjection.js';
 import getEndpointConfig from '../endpoints/getEndpointConfig.js';
 import invokeEndpoint from '../endpoints/invokeEndpoint.js';
 import authorizeAgent from './authorizeAgent.js';
@@ -72,6 +73,11 @@ async function prepareAgent(context, { agentId, agentContext, endpointDepth = 0,
         agentContext,
         i18n: context.i18n,
         mode,
+        // The agent stream's error text reaches the end user and AgentChat config, so it takes
+        // the wire policy. Built here because the agent plugins cannot import @lowdefy/api.
+        // The AI SDK types onError's argument as unknown: a tool can reject with null or a
+        // string, which takes the generic message like any other non-author error.
+        wireErrorMessage: (error)=>createWireProjection(context)(type.isError(error) ? error : new Error(String(error))).message,
         evaluateOperators: (input)=>context.evaluateOperators({
                 input,
                 location: agentConfig.agentId,

package/dist/routes/auth/defaultAuthUrl.js

@@ -0,0 +1,31 @@
+/*
+  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 { type } from '@lowdefy/helpers';
+import getCurrentEnvironment from '../../context/getCurrentEnvironment.js';
+// Auth.js reads its base URL from AUTH_URL (NEXTAUTH_URL is aliased to it at startup). Default it to
+// the current environment's url so a deployment declared in config.environments needs no separate
+// AUTH_URL / NEXTAUTH_URL. The dev server build drops the current environment's url, so the dev
+// server keeps the request origin.
+function defaultAuthUrl({ config }) {
+    // Same "is it set" test as resolveCookies, so both agree on whether an auth URL is configured.
+    if (!type.isNone(process.env.AUTH_URL ?? process.env.NEXTAUTH_URL)) return;
+    const url = getCurrentEnvironment({
+        config
+    })?.url;
+    if (!type.isNone(url)) {
+        process.env.AUTH_URL = url;
+    }
+}
+export default defaultAuthUrl;

package/dist/routes/auth/getAuthConfig.js

@@ -19,11 +19,15 @@ import createCallbacks from './callbacks/createCallbacks.js';
 import createEvents from './events/createEvents.js';
 import createLogger from './createLogger.js';
 import createProviders from './createProviders.js';
+import defaultAuthUrl from './defaultAuthUrl.js';
 import resolveCookies from './resolveCookies.js';
 const authConfigCache = {};
 let initialized = false;
-function getAuthConfig({ appMeta, authJson, dev, logger, plugins, secrets }) {
+function getAuthConfig({ appMeta, authJson, config, dev, logger, plugins, secrets }) {
     if (initialized) return authConfigCache;
+    defaultAuthUrl({
+        config
+    });
     const operatorsParser = new ServerParser({
         lowdefyApp: appMeta,
         operators: {

package/dist/routes/endpoints/callEndpoint.js

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

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

@@ -14,20 +14,17 @@
   limitations under the License.
 */ import { ConfigError } from '@lowdefy/errors';
 import runRoutine from '../runRoutine.js';
+import evaluateRoutineOperators from '../evaluateRoutineOperators.js';
 async function controlFor(context, routineContext, { control }) {
-    const { endpointId, logger, evaluateOperators } = context;
+    const { endpointId, logger } = context;
     const { items } = routineContext;
     const itemName = control[':for'];
     if (!itemName) {
         throw new Error(`Invalid :for in endpoint "${endpointId}" - missing variable name in :for.`);
     }
-    const array = evaluateOperators({
+    const array = evaluateRoutineOperators(context, routineContext, {
         input: control[':in'],
-        items,
-        location: control['~k'] ?? ':for',
-        payload: routineContext.payload,
-        state: routineContext.state,
-        steps: routineContext.steps
+        location: control['~k'] ?? ':for'
     });
     logger.debug({
         event: 'debug_control_for',

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

@@ -13,16 +13,12 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import runRoutine from '../runRoutine.js';
+import evaluateRoutineOperators from '../evaluateRoutineOperators.js';
 async function controlIf(context, routineContext, { control }) {
-    const { endpointId, logger, evaluateOperators } = context;
-    const { items } = routineContext;
-    const evaluatedIf = evaluateOperators({
+    const { endpointId, logger } = context;
+    const evaluatedIf = evaluateRoutineOperators(context, routineContext, {
         input: control[':if'],
-        items,
-        location: control['~k'] ?? ':if',
-        payload: routineContext.payload,
-        state: routineContext.state,
-        steps: routineContext.steps
+        location: control['~k'] ?? ':if'
     });
     logger.debug({
         event: 'debug_control_if',

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

@@ -14,28 +14,20 @@
   limitations under the License.
 */ import { type } from '@lowdefy/helpers';
 import { ConfigError } from '@lowdefy/errors';
+import evaluateRoutineOperators from '../evaluateRoutineOperators.js';
 async function controlLog(context, routineContext, { control }) {
-    const { endpointId, logger, evaluateOperators } = context;
-    const { items } = routineContext;
+    const { endpointId, logger } = context;
     const location = control['~k'] ?? ':log';
     logger.debug({
         event: 'debug_control_log'
     });
-    const log = evaluateOperators({
+    const log = evaluateRoutineOperators(context, routineContext, {
         input: control[':log'],
-        items,
-        location,
-        payload: routineContext.payload,
-        state: routineContext.state,
-        steps: routineContext.steps
+        location
     });
-    const logLevel = evaluateOperators({
+    const logLevel = evaluateRoutineOperators(context, routineContext, {
         input: control[':level'],
-        items,
-        location,
-        payload: routineContext.payload,
-        state: routineContext.state,
-        steps: routineContext.steps
+        location
     }) ?? 'info';
     if (!type.isString(logLevel)) {
         throw new ConfigError(`Invalid :log in endpoint "${endpointId}" - :level must be a string.`, {

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

@@ -14,20 +14,17 @@
   limitations under the License.
 */ import { ConfigError } from '@lowdefy/errors';
 import runRoutine from '../runRoutine.js';
+import evaluateRoutineOperators from '../evaluateRoutineOperators.js';
 async function controlParallelFor(context, routineContext, { control }) {
-    const { endpointId, logger, evaluateOperators } = context;
+    const { endpointId, logger } = context;
     const { items } = routineContext;
     const itemName = control[':parallel_for'];
     if (!itemName) {
         throw new Error(`Invalid :parallel_for in endpoint "${endpointId}" - missing variable name in :parallel_for.`);
     }
-    const array = evaluateOperators({
+    const array = evaluateRoutineOperators(context, routineContext, {
         input: control[':in'],
-        items,
-        location: control['~k'] ?? ':parallel_for',
-        payload: routineContext.payload,
-        state: routineContext.state,
-        steps: routineContext.steps
+        location: control['~k'] ?? ':parallel_for'
     });
     logger.debug({
         event: 'debug_control_parallel',

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

@@ -13,27 +13,25 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { UserError } from '@lowdefy/errors';
+import { type } from '@lowdefy/helpers';
+import createWireProjection from '../../../response/createWireProjection.js';
+import evaluateRoutineOperators from '../evaluateRoutineOperators.js';
 async function controlReject(context, routineContext, { control }) {
-    const { evaluateOperators } = context;
-    const { items } = routineContext;
     const location = control['~k'] ?? ':reject';
-    const message = evaluateOperators({
+    const message = evaluateRoutineOperators(context, routineContext, {
         input: control[':reject'],
-        items,
-        location,
-        payload: routineContext.payload,
-        state: routineContext.state,
-        steps: routineContext.steps
+        location
     });
-    const cause = evaluateOperators({
+    const cause = evaluateRoutineOperators(context, routineContext, {
         input: control[':cause'],
-        items,
-        location,
-        payload: routineContext.payload,
-        state: routineContext.state,
-        steps: routineContext.steps
+        location
     });
-    const error = new UserError(message, {
+    // A reject is the author telling the user something, so it stays a UserError, whose message the
+    // wire passes through as written. An Error given as the message is reduced to what the wire
+    // would show for it - the author's text for a UserError, the generic message for a plugin error
+    // - rather than stringified with its library text; `{ _error: message }` opts into the real text.
+    const text = type.isError(message) ? createWireProjection(context)(message).message : message;
+    const error = new UserError(text, {
         cause,
         isReject: true
     });

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

@@ -12,16 +12,11 @@
   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.
-*/ async function controlReturn(context, routineContext, { control }) {
-    const { evaluateOperators } = context;
-    const { items } = routineContext;
-    const response = evaluateOperators({
+*/ import evaluateRoutineOperators from '../evaluateRoutineOperators.js';
+async function controlReturn(context, routineContext, { control }) {
+    const response = evaluateRoutineOperators(context, routineContext, {
         input: control[':return'],
-        items,
-        location: control['~k'] ?? ':return',
-        payload: routineContext.payload,
-        state: routineContext.state,
-        steps: routineContext.steps
+        location: control['~k'] ?? ':return'
     });
     context.logger.debug({
         event: 'debug_control_return',

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

@@ -14,16 +14,12 @@
   limitations under the License.
 */ import { ConfigError } from '@lowdefy/errors';
 import { ReservedKeyError, set } from '@lowdefy/helpers';
+import evaluateRoutineOperators from '../evaluateRoutineOperators.js';
 function controlSetState(context, routineContext, { control }) {
-    const { logger, evaluateOperators } = context;
-    const { items } = routineContext;
-    const evaluatedSetState = evaluateOperators({
+    const { logger } = context;
+    const evaluatedSetState = evaluateRoutineOperators(context, routineContext, {
         input: control[':set_state'],
-        items,
-        location: control['~k'] ?? ':set_state',
-        payload: routineContext.payload,
-        state: routineContext.state,
-        steps: routineContext.steps
+        location: control['~k'] ?? ':set_state'
     });
     logger.debug({
         event: 'debug_control_set_state',

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

@@ -13,21 +13,17 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import runRoutine from '../runRoutine.js';
+import evaluateRoutineOperators from '../evaluateRoutineOperators.js';
 async function controlSwitch(context, routineContext, { control }) {
-    const { endpointId, logger, evaluateOperators } = context;
-    const { items } = routineContext;
+    const { endpointId, logger } = context;
     const cases = control[':switch'];
     logger.debug({
         event: 'debug_control_switch'
     });
     for (const caseObj of cases){
-        const evaluatedCase = evaluateOperators({
+        const evaluatedCase = evaluateRoutineOperators(context, routineContext, {
             input: caseObj[':case'],
-            items,
-            location: caseObj['~k'] ?? control['~k'] ?? ':switch',
-            payload: routineContext.payload,
-            state: routineContext.state,
-            steps: routineContext.steps
+            location: caseObj['~k'] ?? control['~k'] ?? ':switch'
         });
         logger.debug({
             event: 'debug_control_switch_case',

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

@@ -13,29 +13,27 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { UserError } from '@lowdefy/errors';
+import { type } from '@lowdefy/helpers';
+import evaluateRoutineOperators from '../evaluateRoutineOperators.js';
 async function controlThrow(context, routineContext, { control }) {
-    const { evaluateOperators } = context;
-    const { items } = routineContext;
     const location = control['~k'] ?? ':throw';
-    const message = evaluateOperators({
+    const message = evaluateRoutineOperators(context, routineContext, {
         input: control[':throw'],
-        items,
-        location,
-        payload: routineContext.payload,
-        state: routineContext.state,
-        steps: routineContext.steps
-    });
-    const cause = evaluateOperators({
-        input: control[':cause'],
-        items,
-        location,
-        payload: routineContext.payload,
-        state: routineContext.state,
-        steps: routineContext.steps
-    });
-    const error = new UserError(message, {
-        cause
+        location
     });
+    // An Error, such as a rethrown `_error`, goes on unchanged. Wrapped in a UserError it would be
+    // stringified into the message, which the wire sends as author text; under its own class the
+    // wire makes it generic unless it was a UserError. It carries its own cause, so :cause is unused.
+    let error = message;
+    if (!type.isError(message)) {
+        const cause = evaluateRoutineOperators(context, routineContext, {
+            input: control[':cause'],
+            location
+        });
+        error = new UserError(message, {
+            cause
+        });
+    }
     // Log under `err` — the pino error serializer (createNodeLogger) is registered
     // for the `err` key only; an Error passed as `error` is JSON-dumped without its
     // non-enumerable `message`/`stack`, producing a log line with no message.