@lowdefy/api 5.5.1 → 6.0.0

package/dist/routes/endpoints/runDetachedEndpoint.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 { 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: [],
+        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
             });
@@ -68,9 +80,11 @@ async function runRoutine(context, routineContext, { routine }) {
                 error
             };
         }
+        // handleError sets error.handled once it has logged - it is the single sink
+        // that owns the flag, so a nested runRoutine re-throwing this error does not
+        // log it again.
         if (!error.handled) {
             await context.handleError(error);
-            error.handled = true;
         }
         return {
             status: 'error',

package/dist/routes/endpoints/runScheduledEndpoint.js

@@ -0,0 +1,104 @@
+/*
+  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: [],
+        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;

package/dist/routes/endpoints/runWebhookEndpoint.js

@@ -0,0 +1,83 @@
+/*
+  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 { ConfigError } from '@lowdefy/errors';
+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 declared `webhook: true` — a third-party webhook receiver
+// (SNS, Event Grid, Stripe, ...) served on the standard /api/endpoints route,
+// but taking the request RAW: bodies are the caller's own format, not
+// Lowdefy's { payload } envelope, so the routine receives
+// { body, query, headers } as its payload and its return value is sent back
+// verbatim (handshakes require exact response shapes). Only endpoints that
+// opt in are runnable here (a missing flag reads as a missing endpoint — no
+// probing). The transport is public by design: authenticating the caller
+// (shared-secret query param, signature header) is the webhook routine's own
+// first step. Executes as a system context.
+async function runWebhookEndpoint(context, { endpointId, body, query, headers }) {
+    const { logger } = context;
+    context.endpointId = endpointId;
+    context.evaluateOperators = createEvaluateOperators(context);
+    logger.debug({
+        event: 'debug_webhook_endpoint',
+        endpointId
+    });
+    const endpointConfig = await getEndpointConfig(context, {
+        endpointId
+    });
+    if (endpointConfig.webhook !== true) {
+        const err = new ConfigError(`API Endpoint "${endpointId}" does not exist.`);
+        logger.debug({
+            params: {
+                endpointId
+            },
+            err
+        }, err.message);
+        throw err;
+    }
+    // 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: {
+            body: body ?? null,
+            query: query ?? {},
+            headers: headers ?? {}
+        },
+        arrayIndices: [],
+        items: {},
+        state: {},
+        endpointDepth: 0
+    };
+    const { error, response, status } = await runRoutine(context, routineContext, {
+        routine: endpointConfig.routine
+    });
+    return buildEndpointResult(context, {
+        error,
+        response,
+        status
+    });
+}
+export default runWebhookEndpoint;

package/dist/routes/endpoints/scheduleBackground.js

@@ -0,0 +1,48 @@
+/*
+  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.
+*/ // Run work after the response is sent. Platforms that reap the invocation once
+// the response is flushed (Vercel fluid compute) inject context.waitUntil in
+// their server's apiContext middleware to keep the invocation alive until the
+// promise settles (bounded by the function's maxDuration); locally /
+// self-hosted there is no waitUntil and the promise simply runs detached on
+// the still-alive Node process.
+//
+// The outcome only exists in logs — completion and failure are logged through
+// the request logger so they reach the platform log stream (and any log
+// drains); a background failure must never surface as an unhandled rejection.
+function scheduleBackground(context, { event, endpointId }, fn) {
+    const { logger } = context;
+    const promise = (async ()=>{
+        try {
+            const result = await fn();
+            logger.info({
+                event: `${event}_done`,
+                endpointId,
+                status: result?.status
+            });
+        } catch (err) {
+            logger.error({
+                event: `${event}_failed`,
+                endpointId,
+                err
+            }, err.message);
+        }
+    })();
+    if (context.waitUntil) {
+        context.waitUntil(promise);
+    }
+    return promise;
+}
+export default scheduleBackground;

package/dist/routes/mcp/createMcpServer.js

@@ -0,0 +1,160 @@
+/*
+  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 { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { AuthenticationError } from '@lowdefy/errors';
+import { serializer, type } from '@lowdefy/helpers';
+import callEndpoint from '../endpoints/callEndpoint.js';
+import isUnauthenticatedHuman from '../endpoints/isUnauthenticatedHuman.js';
+// LLM-safe tool names use the same rule as buildAgents tool naming.
+function toToolName(id) {
+    return id.replaceAll('/', '__');
+}
+// Twin of cleanBuildArtifact in packages/utils/ai-utils/src/buildAgentTools.js -
+// duplicated here rather than shared, since pulling in @lowdefy/ai-utils would
+// add the ai SDK and MCP client deps to api just for this. Strips build-artifact
+// serializer markers (~k, ~r, ~l) and unwraps { '~arr': [...] } back to a plain
+// array, so payloadSchema reaches MCP clients as plain JSON Schema.
+function cleanBuildArtifact(obj) {
+    return JSON.parse(JSON.stringify(serializer.deserialize(obj)));
+}
+// A stateless per-request MCP server exposing the configured api endpoints
+// as tools. Built with the SDK's low-level Server: tool input schemas are
+// config-provided JSON Schema (payloadSchema), which the low-level handlers
+// accept directly - no zod conversion. The server is constructed with the
+// request's context, so the caller is known at construction time: tools/list
+// filters by context.authorize, and tools/call re-authorizes inside
+// callEndpoint (defense in depth). Returns null when no mcp block is
+// configured.
+async function createMcpServer({ context }) {
+    const mcpConfig = await context.readConfigFile('mcp.json');
+    if (type.isNone(mcpConfig) || mcpConfig.configured !== true) {
+        return null;
+    }
+    // serverInfo doubles as the connector card in clients such as claude.ai:
+    // title, websiteUrl and icons are optional branding the app may configure,
+    // and are omitted (not sent as undefined) when it does not. icons is config
+    // structure, so like payloadSchema it carries build-artifact markers that
+    // must not reach the client.
+    const serverInfo = {
+        name: mcpConfig.name,
+        version: mcpConfig.version
+    };
+    for (const key of [
+        'title',
+        'websiteUrl'
+    ]){
+        if (!type.isNone(mcpConfig[key])) {
+            serverInfo[key] = mcpConfig[key];
+        }
+    }
+    if (!type.isNone(mcpConfig.icons)) {
+        serverInfo.icons = cleanBuildArtifact(mcpConfig.icons);
+    }
+    const server = new Server(serverInfo, {
+        capabilities: {
+            tools: {}
+        }
+    });
+    server.setRequestHandler(ListToolsRequestSchema, async ()=>{
+        const tools = [];
+        for (const endpointId of mcpConfig.endpoints){
+            const endpointConfig = await context.readConfigFile(`api/${endpointId}.json`);
+            if (type.isNone(endpointConfig) || !context.authorize(endpointConfig)) {
+                continue;
+            }
+            tools.push({
+                name: toToolName(endpointId),
+                description: endpointConfig.description,
+                inputSchema: cleanBuildArtifact(endpointConfig.payloadSchema)
+            });
+        }
+        return {
+            tools
+        };
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request)=>{
+        const { name, arguments: args } = request.params;
+        context.logger.info({
+            event: 'mcp_tool_call',
+            tool: name
+        });
+        const endpointId = mcpConfig.endpoints.find((id)=>toToolName(id) === name);
+        try {
+            if (!type.isNone(endpointId)) {
+                const { error, response, success } = await callEndpoint(context, {
+                    blockId: '_mcp',
+                    endpointId,
+                    pageId: '_mcp',
+                    payload: args ?? {}
+                });
+                if (!success) {
+                    const deserialized = serializer.deserialize(error);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: deserialized?.message ?? 'Endpoint failed.'
+                            }
+                        ],
+                        isError: true
+                    };
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(serializer.deserialize(response))
+                        }
+                    ]
+                };
+            }
+            // An unknown tool answers like a gated one for an anonymous caller on an
+            // auth'd app, so tools/call cannot be used to enumerate tool names that
+            // tools/list already hides from that caller.
+            if (await isUnauthenticatedHuman(context)) {
+                throw new AuthenticationError(`Authentication required for API endpoint "${name}".`);
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Unknown tool "${name}".`
+                    }
+                ],
+                isError: true
+            };
+        } catch (error) {
+            // Unauthenticated calls to gated tools are expected probing traffic -
+            // a warn line and the 401-shaped message, not a structured error log.
+            if (error.name === 'AuthenticationError') {
+                context.logger.warn(`Unauthenticated MCP tool call: ${name}`);
+            } else {
+                context.logger.error(error);
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: error.message
+                    }
+                ],
+                isError: true
+            };
+        }
+    });
+    return server;
+}
+export default createMcpServer;

package/dist/routes/notifications/derivePreview.js

@@ -0,0 +1,30 @@
+/*
+  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';
+// Rough inversion of the interpolation pipeline for the preview text: strip
+// author markdown syntax and unescape the backslash-escaped interpolated values.
+function stripMarkdown(text) {
+    return text.replace(/```[\s\S]*?```/g, ' ').replace(/`([^`]*)`/g, '$1').replace(/!\[([^\]]*)\]\([^)]*\)/g, '$1').replace(/\[([^\]]*)\]\([^)]*\)/g, '$1').replace(/^#{1,6}\s+/gm, '').replace(/^\s*>\s?/gm, '').replace(/^\s*[-*+]\s+/gm, '').replace(/(\*\*|__|\*|_|~~)/g, '').replace(/\\([!-/:-@[-`{-~])/g, '$1').replace(/\s+/g, ' ').trim();
+}
+function derivePreview({ properties }) {
+    if (type.isString(properties.preview) && properties.preview !== '') {
+        return properties.preview;
+    }
+    if (type.isString(properties.message) && properties.message !== '') {
+        return stripMarkdown(properties.message).slice(0, 140);
+    }
+    return null;
+}
+export default derivePreview;

package/dist/routes/notifications/getNotificationConfig.js

@@ -0,0 +1,32 @@
+/*
+  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 { ConfigError } from '@lowdefy/errors';
+async function getNotificationConfig({ logger, readConfigFile }, { notificationId, configKey }) {
+    const notification = await readConfigFile(`notifications/${notificationId}.json`);
+    if (!notification) {
+        const err = new ConfigError(`Notification "${notificationId}" does not exist.`, {
+            configKey
+        });
+        logger.debug({
+            params: {
+                notificationId
+            },
+            err
+        }, err.message);
+        throw err;
+    }
+    return notification;
+}
+export default getNotificationConfig;

package/dist/routes/notifications/resolveNotificationLinks.js

@@ -0,0 +1,72 @@
+/*
+  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, type, urlQuery } from '@lowdefy/helpers';
+function resolveLinkValue({ link, option, serverUrl, basePath, landingPage, recordId }) {
+    // Absolute URLs pass through — links into other apps or external destinations.
+    // They skip any landing page, so they carry no mark-as-read.
+    if (type.isString(link)) {
+        return link;
+    }
+    if (type.isObject(link) && !type.isNone(link.pageId)) {
+        if (type.isNone(landingPage)) {
+            // No landing page configured — link straight to the target page.
+            const query = urlQuery.stringify(link.urlQuery ?? {});
+            return `${serverUrl}${basePath}/${link.pageId}${query ? `?${query}` : ''}`;
+        }
+        // The option query param is the dot-path of the link inside the record's
+        // data — the landing page reads the original target back with
+        // get(record.data, option) after marking the record read.
+        const query = urlQuery.stringify({
+            _id: recordId,
+            option
+        });
+        return `${serverUrl}${basePath}${landingPage}?${query}`;
+    }
+    return link;
+}
+// Resolves link values in a copy of the data item to URLs; the stored record
+// keeps the original { pageId, urlQuery } objects for in-app navigation.
+// data.links is the framework convention; link fields inside arrays are
+// resolved for the data keys the template declares (Template.dataKeys), so
+// custom templates get the same treatment as the built-in ones.
+function resolveNotificationLinks({ item, dataKeys, serverUrl, basePath, landingPage, recordId }) {
+    const resolved = serializer.copy(item);
+    Object.keys(resolved.links ?? {}).forEach((key)=>{
+        resolved.links[key] = resolveLinkValue({
+            link: resolved.links[key],
+            option: `links.${key}`,
+            serverUrl,
+            basePath,
+            landingPage,
+            recordId
+        });
+    });
+    (dataKeys ?? []).forEach((arrayKey)=>{
+        if (!type.isArray(resolved[arrayKey])) return;
+        resolved[arrayKey].forEach((entry, index)=>{
+            if (!type.isObject(entry) || type.isNone(entry.link)) return;
+            entry.link = resolveLinkValue({
+                link: entry.link,
+                option: `${arrayKey}.${index}.link`,
+                serverUrl,
+                basePath,
+                landingPage,
+                recordId
+            });
+        });
+    });
+    return resolved;
+}
+export default resolveNotificationLinks;

package/dist/routes/notifications/resolveThemeLogo.js

@@ -0,0 +1,35 @@
+/*
+  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';
+// A theme logo written as an app-relative path ("/logo.png", a public/ asset)
+// resolves against the deployment's serverUrl + basePath, so one config works
+// across environments. Absolute ("https://...") and protocol-relative ("//...")
+// URLs pass through. Without a serverUrl an email client can never fetch a
+// relative path, so the logo is dropped — EmailLayout falls back to the
+// companyName text header, which beats a broken image.
+function resolveThemeLogo({ theme, serverUrl, basePath }) {
+    const { logo, ...rest } = theme;
+    if (!type.isString(logo) || !logo.startsWith('/') || logo.startsWith('//')) {
+        return theme;
+    }
+    if (type.isNone(serverUrl)) {
+        return rest;
+    }
+    return {
+        ...rest,
+        logo: `${serverUrl}${basePath}${logo}`
+    };
+}
+export default resolveThemeLogo;