@lowdefy/api 5.6.0 → 6.1.0

package/dist/routes/endpoints/handleEndpointCall.js

@@ -12,23 +12,68 @@
   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 addStepResult from './addStepResult.js';
+*/ import { serializer } from '@lowdefy/helpers';
+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
+    // with a fresh duration budget (chainable bounded work without a queue).
+    // At-most-once, no retry: targets must be idempotent. The dispatch promise
+    // rides the platform request context so the outgoing request always leaves
+    // before the invocation is reaped; the target's own outcome exists only in
+    // its logs and whatever its routine writes.
+    if (evaluatedProperties.detached === true) {
+        if (!process.env.CRON_SECRET) {
+            throw new ConfigError('CallApi with "detached: true" requires the CRON_SECRET environment variable — the /api/detached route fails closed without it.');
+        }
+        if (!context.origin) {
+            throw new ConfigError('Detached endpoint calls require the request origin on context.');
+        }
+        const targetEndpointId = evaluatedProperties.endpointId;
+        scheduleBackground(context, {
+            event: 'detached_dispatch',
+            endpointId: targetEndpointId
+        }, ()=>fetch(`${context.origin}/api/detached/${targetEndpointId}`, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    authorization: `Bearer ${process.env.CRON_SECRET}`
+                },
+                body: JSON.stringify({
+                    payload: serializer.serialize(evaluatedProperties.payload ?? {})
+                })
+            }));
+        addStepResult(context, routineContext, {
+            result: {
+                detached: true,
+                endpointId: targetEndpointId
+            },
+            stepId: step.stepId
+        });
+        logger.debug({
+            event: 'debug_end_endpoint_call',
+            stepId: step.stepId,
+            targetEndpointId,
+            detached: true
+        });
+        return {
+            status: 'continue'
+        };
+    }
     const result = await invokeEndpoint(context, {
         endpointId: evaluatedProperties.endpointId,
         payload: evaluatedProperties.payload,

package/dist/routes/endpoints/handleRenderNotification.js

@@ -0,0 +1,196 @@
+/*
+  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 { validate } from '@lowdefy/ajv';
+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));
+    return [
+        ...links,
+        ...arrayLinks
+    ].some((link)=>type.isObject(link) && !type.isNone(link.pageId));
+}
+async function handleRenderNotification(context, routineContext, { step }) {
+    const { logger } = context;
+    logger.debug({
+        event: 'debug_start_render_notification',
+        step
+    });
+    const evaluatedProperties = evaluateRoutineOperators(context, routineContext, {
+        input: step.properties,
+        location: step.stepId
+    });
+    const { notificationId, data, landingPage, recordId } = evaluatedProperties;
+    let { serverUrl } = evaluatedProperties;
+    if (!type.isString(notificationId)) {
+        throw new ConfigError(`RenderNotification step "${step.stepId}" properties.notificationId must evaluate to a string. Received ${JSON.stringify(notificationId)}.`, {
+            configKey: step['~k']
+        });
+    }
+    if (type.isArray(data)) {
+        throw new ConfigError(`RenderNotification step "${step.stepId}" properties.data must evaluate to an object. Received an array — iterate with a ":for" control and render one item per step.`, {
+            configKey: step['~k']
+        });
+    }
+    if (!type.isObject(data)) {
+        throw new ConfigError(`RenderNotification step "${step.stepId}" properties.data must evaluate to an object. Received ${JSON.stringify(data)}.`, {
+            configKey: step['~k']
+        });
+    }
+    if (!type.isNone(serverUrl)) {
+        if (!type.isString(serverUrl) || serverUrl === '') {
+            throw new ConfigError(`RenderNotification step "${step.stepId}" properties.serverUrl must evaluate to a non-empty string. Received ${JSON.stringify(serverUrl)}.`, {
+                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)) {
+        throw new ConfigError(`RenderNotification step "${step.stepId}" properties.landingPage must evaluate to a string. Received ${JSON.stringify(landingPage)}.`, {
+            configKey: step['~k']
+        });
+    }
+    if (!type.isNone(recordId) && !type.isString(recordId)) {
+        throw new ConfigError(`RenderNotification step "${step.stepId}" properties.recordId must evaluate to a string. Received ${JSON.stringify(recordId)}.`, {
+            configKey: step['~k']
+        });
+    }
+    const notificationConfig = await getNotificationConfig(context, {
+        notificationId,
+        configKey: step['~k']
+    });
+    const configKey = notificationConfig['~k'];
+    const Template = context.notifications[notificationConfig.type];
+    if (!Template) {
+        throw new ConfigError(`Notification template type "${notificationConfig.type}" can not be found.`, {
+            configKey
+        });
+    }
+    const { renderEmail, interpolateProperties } = context;
+    if (!type.isFunction(renderEmail) || !type.isFunction(interpolateProperties)) {
+        // plugins/notifications.js exports real implementations whenever the app
+        // has notifications built — reaching this means the build artifact and
+        // config are out of sync.
+        throw new ConfigError('Email rendering is not available. Rebuild the app — @lowdefy/email-templates is installed when "notifications:" is configured.', {
+            configKey
+        });
+    }
+    const app = await context.readConfigFile('app.json') ?? {};
+    const basePath = context.config?.basePath ?? '';
+    // Resolve after the merge so a per-notification theme.logo override also
+    // resolves; precedence stays notification theme over app.email.
+    const theme = resolveThemeLogo({
+        theme: {
+            ...app.email ?? {},
+            ...notificationConfig.theme ?? {}
+        },
+        serverUrl,
+        basePath
+    });
+    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, or the url of the current environment in config.environments.`, {
+                configKey: step['~k']
+            });
+        }
+        // Landing URLs embed the record id — without it the landing page cannot
+        // resolve the record and every link in the email would be dead.
+        if (!type.isNone(landingPage) && type.isNone(recordId)) {
+            throw new ConfigError(`RenderNotification step "${step.stepId}" properties.landingPage requires properties.recordId to compose landing URLs.`, {
+                configKey: step['~k']
+            });
+        }
+    }
+    const resolvedItem = resolveNotificationLinks({
+        item: data,
+        dataKeys: Template.dataKeys ?? [],
+        serverUrl: serverUrl ?? '',
+        basePath,
+        landingPage,
+        recordId
+    });
+    let interpolated;
+    try {
+        interpolated = interpolateProperties({
+            properties: notificationConfig.properties,
+            data: resolvedItem,
+            markdownProperties: Template.markdownProperties ?? []
+        });
+    } catch (error) {
+        throw new ConfigError(`Notification "${notificationId}" template interpolation failed: ${error.message}`, {
+            configKey,
+            cause: error
+        });
+    }
+    if (Template.schema) {
+        const { valid, errors } = validate({
+            schema: Template.schema,
+            data: interpolated,
+            returnErrors: true
+        });
+        if (!valid) {
+            throw new ConfigError(`Notification "${notificationId}" properties do not match template "${notificationConfig.type}" schema: ${errors?.[0]?.message}.`, {
+                configKey
+            });
+        }
+    }
+    const { html, text } = await renderEmail({
+        Template,
+        properties: interpolated,
+        data: resolvedItem,
+        theme,
+        links: resolvedItem.links ?? {}
+    });
+    const result = {
+        subject: interpolated.subject,
+        title: interpolated.title ?? interpolated.subject,
+        preview: derivePreview({
+            properties: interpolated
+        }),
+        html,
+        text,
+        data: resolvedItem
+    };
+    addStepResult(context, routineContext, {
+        result,
+        stepId: step.stepId
+    });
+    logger.debug({
+        event: 'debug_end_render_notification',
+        stepId: step.stepId,
+        notificationId
+    });
+    return {
+        status: 'continue'
+    };
+}
+export default handleRenderNotification;

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,13 +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,
-            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/isUnauthenticatedHuman.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';
+// True for a session-less caller on an app that has auth configured, outside a
+// system run. This is the one caller who must get the same answer for a missing
+// id as for a protected one - "authenticate" - or a logged-out client can
+// enumerate endpoint ids by response difference (500/does-not-exist for a miss
+// versus 401 for a protected id). "No user" is not enough on its own: it is also
+// "no auth in this app" and "the engine talking to itself" (scheduled, webhook
+// and detached runs), and neither should be told to authenticate against
+// nothing. auth.json is a build artifact the build always writes.
+async function isUnauthenticatedHuman({ readConfigFile, system, user }) {
+    if (!type.isNone(user) || system === true) {
+        return false;
+    }
+    const authConfig = await readConfigFile('auth.json');
+    return authConfig?.configured === true;
+}
+export default isUnauthenticatedHuman;

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

@@ -0,0 +1,38 @@
+/*
+  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 { 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 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?.environments;
+    if (type.isNone(environments)) {
+        if (!type.isNone(environment)) {
+            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 config.environments.`);
+        }
+        return environment;
+    }
+    return config.environment;
+}
+export default resolveCronEnvironment;

package/dist/routes/endpoints/runDetachedEndpoint.js

@@ -0,0 +1,67 @@
+/*
+  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 buildEndpointResult from '../../response/buildEndpointResult.js';
+import createAuthorize from '../../context/createAuthorize.js';
+import createEvaluateOperators from '../../context/createEvaluateOperators.js';
+import getEndpointConfig from './getEndpointConfig.js';
+import runRoutine from './runRoutine.js';
+// Runs an endpoint invoked through the detached route (a CallApi step with
+// `detached: true` fire-and-forgets an HTTP call back to the deployment, so the
+// target runs in its OWN function invocation with a fresh duration budget).
+// Like a cron run this is authorized by the transport layer (CRON_SECRET) and
+// executes as a system context: no user session, `_user` resolves to undefined,
+// and InternalApi endpoints are callable. Payload arrives serialized (dates
+// etc. survive the HTTP hop via @lowdefy/helpers serializer).
+async function runDetachedEndpoint(context, { endpointId, payload }) {
+    const { logger } = context;
+    context.endpointId = endpointId;
+    context.evaluateOperators = createEvaluateOperators(context);
+    logger.debug({
+        event: 'debug_detached_endpoint',
+        endpointId
+    });
+    const endpointConfig = await getEndpointConfig(context, {
+        endpointId
+    });
+    // Force a system context regardless of any session cookie sent with the request.
+    // system: true — nested CallApi steps are authorized like function calls (the run
+    // was already authorized at the transport layer), not re-gated on a user session.
+    context.session = undefined;
+    context.user = undefined;
+    context.system = true;
+    context.authorize = createAuthorize({
+        session: undefined,
+        system: true
+    });
+    const routineContext = {
+        steps: {},
+        payload: serializer.deserialize(payload ?? {}),
+        arrayIndices: [],
+        error: null,
+        items: {},
+        state: {},
+        endpointDepth: 0
+    };
+    const { error, response, status } = await runRoutine(context, routineContext, {
+        routine: endpointConfig.routine
+    });
+    return buildEndpointResult(context, {
+        error,
+        response,
+        status
+    });
+}
+export default runDetachedEndpoint;

package/dist/routes/endpoints/runRoutine.js

@@ -13,8 +13,10 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { type } from '@lowdefy/helpers';
+import handleAgentCall from './handleAgentCall.js';
 import handleControl from './control/handleControl.js';
 import handleEndpointCall from './handleEndpointCall.js';
+import handleRenderNotification from './handleRenderNotification.js';
 import handleRequest from './handleRequest.js';
 import handleValidateSchema from './handleValidateSchema.js';
 async function runRoutine(context, routineContext, { routine }) {
@@ -35,6 +37,16 @@ async function runRoutine(context, routineContext, { routine }) {
                     step: routine
                 });
             }
+            if (routine.id?.startsWith?.('agent:')) {
+                return await handleAgentCall(context, routineContext, {
+                    step: routine
+                });
+            }
+            if (routine.id?.startsWith?.('notification:')) {
+                return await handleRenderNotification(context, routineContext, {
+                    step: routine
+                });
+            }
             return await handleControl(context, routineContext, {
                 control: routine
             });

package/dist/routes/endpoints/runScheduledEndpoint.js

@@ -0,0 +1,105 @@
+/*
+  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 createAuthorize from '../../context/createAuthorize.js';
+import buildEndpointResult from '../../response/buildEndpointResult.js';
+import createEvaluateOperators from '../../context/createEvaluateOperators.js';
+import findSchedule from './findSchedule.js';
+import getEndpointConfig from './getEndpointConfig.js';
+import getEnvironmentSchedules from './getEnvironmentSchedules.js';
+import resolveCronEnvironment from './resolveCronEnvironment.js';
+import runRoutine from './runRoutine.js';
+import scheduleBackground from './scheduleBackground.js';
+// Runs an endpoint routine on a schedule (cron). Unlike callEndpoint this does NOT check the
+// endpoint's `auth` config and does NOT block InternalApi: a cron run is authorized by the transport
+// layer (CRON_SECRET) plus the endpoint declaring the firing schedule, and runs as a system context
+// (no user session, so `_user` resolves to undefined). An InternalApi with schedules is therefore a
+// cron-only endpoint that is never client-callable.
+// `environment` (x-lowdefy-cron-environment, set on requests forwarded from the production
+// deployment) selects which environment's schedules apply; see resolveCronEnvironment.
+async function runScheduledEndpoint(context, { endpointId, cron, environment }) {
+    const { logger } = context;
+    context.endpointId = endpointId;
+    context.evaluateOperators = createEvaluateOperators(context);
+    const cronEnvironment = resolveCronEnvironment({
+        config: context.config,
+        environment
+    });
+    logger.debug({
+        event: 'debug_scheduled_endpoint',
+        endpointId,
+        cron,
+        environment: cronEnvironment
+    });
+    const endpointConfig = await getEndpointConfig(context, {
+        endpointId
+    });
+    const schedules = getEnvironmentSchedules({
+        endpointConfig,
+        environment: cronEnvironment
+    });
+    const schedule = findSchedule({
+        schedules,
+        cron,
+        endpointId,
+        environment: cronEnvironment
+    });
+    // Force a system context regardless of any session cookie sent with the request.
+    // system: true — nested CallApi steps are authorized like function calls (the run
+    // was already authorized at the transport layer), not re-gated on a user session.
+    context.session = undefined;
+    context.user = undefined;
+    context.system = true;
+    context.authorize = createAuthorize({
+        session: undefined,
+        system: true
+    });
+    const routineContext = {
+        steps: {},
+        payload: schedule.payload ?? {},
+        arrayIndices: [],
+        error: null,
+        items: {},
+        state: {},
+        endpointDepth: 0
+    };
+    // async: true — acknowledge the cron trigger immediately and run in the
+    // background; transport auth (CRON_SECRET) already passed at the route.
+    if (endpointConfig.async === true) {
+        scheduleBackground(context, {
+            event: 'background_scheduled_endpoint',
+            endpointId
+        }, ()=>runRoutine(context, routineContext, {
+                routine: endpointConfig.routine
+            }));
+        return {
+            error: null,
+            response: serializer.serialize({
+                accepted: true
+            }),
+            status: 'accepted',
+            success: true
+        };
+    }
+    const { error, response, status } = await runRoutine(context, routineContext, {
+        routine: endpointConfig.routine
+    });
+    return buildEndpointResult(context, {
+        error,
+        response,
+        status
+    });
+}
+export default runScheduledEndpoint;