@lowdefy/build 5.5.1 → 6.0.0

package/dist/build/writeNotifications.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, serializer } from '@lowdefy/helpers';
+async function writeNotification({ notification, context }) {
+    await context.writeBuildArtifact(`notifications/${notification.notificationId}.json`, serializer.serializeToString(notification ?? {}));
+}
+async function writeNotifications({ components, context }) {
+    if (type.isNone(components.notifications)) return;
+    if (!type.isArray(components.notifications)) {
+        throw new Error(`Notifications is not an array.`);
+    }
+    const writePromises = components.notifications.map((notification)=>writeNotification({
+            notification,
+            context
+        }));
+    return Promise.all(writePromises);
+}
+export default writeNotifications;

package/dist/build/writePluginImports/importPluginModule.js

@@ -0,0 +1,39 @@
+/*
+  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 { createRequire } from 'node:module';
+import path from 'node:path';
+// Import a plugin module (e.g. `${pkg}/schemas`, `${pkg}/connections`) for
+// schema collection. Default packages resolve from the build package itself;
+// custom plugins only exist in the server's node_modules, so fall back to
+// resolving from the server directory. Returns undefined when unresolvable —
+// callers degrade gracefully.
+async function importPluginModule({ context, specifier }) {
+    try {
+        return await import(/* webpackIgnore: true */ /* @vite-ignore */ specifier);
+    } catch  {
+    // Not resolvable from the build package — try the server's node_modules.
+    }
+    const serverDir = context.directories?.server;
+    if (!serverDir) {
+        return undefined;
+    }
+    try {
+        const require = createRequire(path.join(serverDir, 'package.json'));
+        return await import(/* webpackIgnore: true */ /* @vite-ignore */ require.resolve(specifier));
+    } catch  {
+        return undefined;
+    }
+}
+export default importPluginModule;

package/dist/build/writePluginImports/writeActionSchemaMap.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.
-*/ async function writeActionSchemaMap({ components, context }) {
+*/ import importPluginModule from './importPluginModule.js';
+async function writeActionSchemaMap({ components, context }) {
     const schemas = {};
     const typesMapSchemas = context.typesMap.schemas?.actions ?? {};
     const actionsByPackage = {};
@@ -23,12 +24,10 @@
         actionsByPackage[action.package].push(action);
     }
     for (const [packageName, actions] of Object.entries(actionsByPackage)){
-        let packageSchemas;
-        try {
-            packageSchemas = await import(/* webpackIgnore: true */ `${packageName}/schemas`);
-        } catch  {
-        // Package not resolvable from build context (custom plugins) — skip
-        }
+        const packageSchemas = await importPluginModule({
+            context,
+            specifier: `${packageName}/schemas`
+        });
         for (const action of actions){
             if (typesMapSchemas[action.typeName]) {
                 schemas[action.typeName] = typesMapSchemas[action.typeName];

package/dist/build/writePluginImports/writeAuthImports.js

@@ -30,5 +30,9 @@ async function writeAuthImports({ components, context }) {
         imports: components.imports.auth.providers,
         importPath: 'auth/providers'
     }));
+    await context.writeBuildArtifact('plugins/auth/strategies.js', generateImportFile({
+        imports: components.imports.auth.strategies,
+        importPath: 'auth/strategies'
+    }));
 }
 export default writeAuthImports;

package/dist/build/writePluginImports/writeAvailableTypes.js

@@ -0,0 +1,99 @@
+/*
+  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.
+*/ function filterInstalled({ store, installedPackages }) {
+    const filtered = {};
+    for (const [typeName, definition] of Object.entries(store ?? {})){
+        if (installedPackages.has(definition.package)) {
+            filtered[typeName] = definition;
+        }
+    }
+    return filtered;
+}
+// Discovery artifact for the dev server docs routes: every type available
+// from installed plugin packages, independent of whether the app config uses
+// it. types.json only describes types counted in config (plus dev-installed
+// blocks/actions/operators), so docs tooling needs this full map to list what
+// a developer could use. Dev-only — context.installedPackages is set by the
+// dev shallow build (addInstalledTypes); production builds skip it.
+async function writeAvailableTypes({ context }) {
+    const { typesMap, installedPackages } = context;
+    if (!installedPackages) {
+        return;
+    }
+    const availableTypes = {
+        actions: filterInstalled({
+            store: typesMap.actions,
+            installedPackages
+        }),
+        agents: filterInstalled({
+            store: typesMap.agents,
+            installedPackages
+        }),
+        auth: {
+            adapters: filterInstalled({
+                store: typesMap.auth.adapters,
+                installedPackages
+            }),
+            callbacks: filterInstalled({
+                store: typesMap.auth.callbacks,
+                installedPackages
+            }),
+            events: filterInstalled({
+                store: typesMap.auth.events,
+                installedPackages
+            }),
+            providers: filterInstalled({
+                store: typesMap.auth.providers,
+                installedPackages
+            }),
+            strategies: filterInstalled({
+                store: typesMap.auth.strategies,
+                installedPackages
+            })
+        },
+        blocks: filterInstalled({
+            store: typesMap.blocks,
+            installedPackages
+        }),
+        connections: filterInstalled({
+            store: typesMap.connections,
+            installedPackages
+        }),
+        notifications: filterInstalled({
+            store: typesMap.notifications,
+            installedPackages
+        }),
+        operators: {
+            client: filterInstalled({
+                store: typesMap.operators.client,
+                installedPackages
+            }),
+            server: filterInstalled({
+                store: typesMap.operators.server,
+                installedPackages
+            })
+        },
+        requests: filterInstalled({
+            store: typesMap.requests,
+            installedPackages
+        }),
+        websockets: filterInstalled({
+            store: typesMap.websockets,
+            installedPackages
+        })
+    };
+    await context.writeBuildArtifact('plugins/availableTypes.json', JSON.stringify(availableTypes));
+}
+export default writeAvailableTypes;

package/dist/build/writePluginImports/writeBlockSchemaMap.js

@@ -13,6 +13,7 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { buildBlockSchema } from '@lowdefy/block-utils';
+import importPluginModule from './importPluginModule.js';
 async function writeBlockSchemaMap({ components, context }) {
     const schemas = {};
     const allMetas = {};
@@ -25,15 +26,15 @@ async function writeBlockSchemaMap({ components, context }) {
         blocksByPackage[block.package].push(block);
     }
     for (const [packageName, blocks] of Object.entries(blocksByPackage)){
-        let packageMetas;
-        try {
-            packageMetas = await import(/* webpackIgnore: true */ `${packageName}/metas`);
-        } catch  {
-            try {
-                packageMetas = await import(/* webpackIgnore: true */ `${packageName}/schemas`);
-            } catch  {
-            // Package not resolvable from build context (custom plugins) — skip
-            }
+        let packageMetas = await importPluginModule({
+            context,
+            specifier: `${packageName}/metas`
+        });
+        if (!packageMetas) {
+            packageMetas = await importPluginModule({
+                context,
+                specifier: `${packageName}/schemas`
+            });
         }
         for (const block of blocks){
             const meta = packageMetas?.[block.originalTypeName];

package/dist/build/writePluginImports/writeConnectionSchemaMap.js

@@ -0,0 +1,101 @@
+/*
+  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 importPluginModule from './importPluginModule.js';
+// Connection and request schemas live as statics on the connection classes
+// (Connection.schema, Connection.requests[Request].schema), not behind a
+// package /schemas export. Collect them here, in the build process, so the
+// dev server can serve schemas for every installed connection package without
+// importing heavy connection dependencies (database drivers etc.) at runtime.
+// Dev-only — context.installedPackages is set by the dev shallow build
+// (addInstalledTypes); production builds skip it.
+async function writeConnectionSchemaMap({ context }) {
+    const { installedPackages } = context;
+    if (!installedPackages) {
+        return;
+    }
+    const connectionSchemas = {};
+    const requestSchemas = {};
+    const typesMapConnectionSchemas = context.typesMap.schemas?.connections ?? {};
+    const typesMapRequestSchemas = context.typesMap.schemas?.requests ?? {};
+    const connectionsByPackage = {};
+    for (const [typeName, definition] of Object.entries(context.typesMap.connections ?? {})){
+        if (!installedPackages.has(definition.package)) {
+            continue;
+        }
+        if (!connectionsByPackage[definition.package]) {
+            connectionsByPackage[definition.package] = [];
+        }
+        connectionsByPackage[definition.package].push({
+            typeName,
+            ...definition
+        });
+    }
+    const requestsByPackage = {};
+    for (const [typeName, definition] of Object.entries(context.typesMap.requests ?? {})){
+        if (!installedPackages.has(definition.package)) {
+            continue;
+        }
+        if (!requestsByPackage[definition.package]) {
+            requestsByPackage[definition.package] = [];
+        }
+        requestsByPackage[definition.package].push({
+            typeName,
+            ...definition
+        });
+    }
+    const packageNames = new Set([
+        ...Object.keys(connectionsByPackage),
+        ...Object.keys(requestsByPackage)
+    ]);
+    for (const packageName of packageNames){
+        const packageConnections = await importPluginModule({
+            context,
+            specifier: `${packageName}/connections`
+        });
+        const requestFnsByOriginalName = {};
+        for (const connection of Object.values(packageConnections ?? {})){
+            for (const [requestName, requestFn] of Object.entries(connection?.requests ?? {})){
+                requestFnsByOriginalName[requestName] = requestFn;
+            }
+        }
+        for (const connection of connectionsByPackage[packageName] ?? []){
+            const originalTypeName = connection.originalTypeName ?? connection.typeName;
+            const implementation = packageConnections?.[originalTypeName];
+            const typePrefix = connection.typeName.slice(0, connection.typeName.length - originalTypeName.length);
+            if (typesMapConnectionSchemas[connection.typeName]) {
+                connectionSchemas[connection.typeName] = typesMapConnectionSchemas[connection.typeName];
+            } else if (implementation?.schema) {
+                connectionSchemas[connection.typeName] = {
+                    schema: implementation.schema,
+                    requests: Object.keys(implementation.requests ?? {}).map((requestName)=>`${typePrefix}${requestName}`)
+                };
+            }
+        }
+        for (const request of requestsByPackage[packageName] ?? []){
+            const requestFn = requestFnsByOriginalName[request.originalTypeName ?? request.typeName];
+            if (typesMapRequestSchemas[request.typeName]) {
+                requestSchemas[request.typeName] = typesMapRequestSchemas[request.typeName];
+            } else if (requestFn?.schema) {
+                requestSchemas[request.typeName] = {
+                    schema: requestFn.schema,
+                    meta: requestFn.meta ?? {}
+                };
+            }
+        }
+    }
+    await context.writeBuildArtifact('plugins/connectionSchemas.json', JSON.stringify(connectionSchemas));
+    await context.writeBuildArtifact('plugins/requestSchemas.json', JSON.stringify(requestSchemas));
+}
+export default writeConnectionSchemaMap;

package/dist/build/writePluginImports/writeGlobalsCss.js

@@ -62,7 +62,6 @@ function objectToThemeVars(obj, prefix) {
 }
 function buildThemeVars(tailwindConfig) {
     const merged = mergeObjects([
-        {},
         BRIDGE_DEFAULTS,
         tailwindConfig ?? {}
     ]);
@@ -81,20 +80,31 @@ async function writeGlobalsCss({ components, context }) {
         const relPath = path.relative(context.directories.build, userStylesAbsolute).split(path.sep).join('/');
         userStylesImport = `/* User custom styles */\n@import "${relPath}" layer(components);\n\n`;
     }
+    // All @import statements must precede @source and every other statement —
+    // the CSS spec only allows @charset and empty @layer before @import, and
+    // Vite's CSS pipeline enforces this (it warns and may drop late imports).
     const css = `/* Generated by Lowdefy build */
 
 /* Layer order — locks cascade priority before Tailwind declares its own layers */
 @layer theme, base, antd, components, utilities;
 
-@import "tailwindcss";
+/* source(none) disables Tailwind's automatic source detection — without it the
+   oxide scanner walks the entire server directory tree (node_modules and all,
+   ~50s cold) on the first CSS compile. The explicit @source globs below are
+   the only scan inputs Lowdefy needs. */
+@import "tailwindcss" source(none);
 @import "@lowdefy/layout/grid.css";
 
+/* Imported CSS file — when this changes, PostCSS re-runs and Tailwind re-scans @source.
+   This import is the ONLY recompile trigger in dev: the @source .html files below are
+   deliberately excluded from Vite's watcher (server.watch.ignored in the dev server's
+   vite.config.js) because watched .html changes force full browser reloads. The JIT
+   page builder touches this file whenever tailwind content changes. */
+@import "./tailwind-candidates.css";
+
 ${userStylesImport}/* Content sources for Tailwind JIT — block JS content collected at build time */
 @source "../lowdefy-build/tailwind/*.html";
 
-/* Imported CSS file — when this changes, PostCSS re-runs and Tailwind re-scans @source */
-@import "./tailwind-candidates.css";
-
 /* Themed scrollbars — opts out of the browser default that clashes on dark surfaces,
    especially on Windows/Linux where scrollbars are always visible and native-chrome.
    Colors use antd CSS custom properties so they auto-swap with dark/light mode. */
@@ -130,12 +140,11 @@ ${themeVars}
 }
 `;
     await context.writeBuildArtifact('globals.css', css);
-    // Standalone layer order declaration — imported FIRST in _app.js so that
-    // Next.js/Turbopack generates a critical CSS chunk that loads before any
-    // JavaScript (including antd's CSS-in-JS). This guarantees the cascade
-    // layer priority is locked (antd > base/preflight) before antd injects
-    // @layer antd {} at runtime. Without this, antd wins the race and becomes
-    // the lowest-priority layer.
+    // Standalone layer order declaration — imported FIRST in the client entry
+    // (client/main.jsx) so the cascade layer priority is locked
+    // (antd > base/preflight) before antd's CSS-in-JS injects @layer antd {}
+    // at runtime. Without this, antd wins the race and becomes the
+    // lowest-priority layer.
     await context.writeBuildArtifact('layer-order.css', '/* Generated by Lowdefy build */\n@layer theme, base, antd, components, utilities;\n');
     await context.writeBuildArtifact('tailwind-candidates.css', '/* Generated by Lowdefy build — rewritten on page changes to trigger CSS recompilation */\n');
     for (const [pageId, content] of context.tailwindContentMap ?? []){

package/dist/build/writePluginImports/writeNotificationImports.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 generateImportFile from './generateImportFile.js';
+async function writeNotificationImports({ components, context }) {
+    const registry = generateImportFile({
+        imports: components.imports.notifications,
+        importPath: 'notifications'
+    });
+    // The servers statically import renderEmail and interpolateProperties from this
+    // file, so both named exports must always exist. Apps with notifications get
+    // the real implementations; apps without notifications never install
+    // @lowdefy/email-templates, so the exports are undefined placeholders.
+    const helperExports = (components.notifications ?? []).length > 0 ? `export { renderEmail, interpolateProperties } from '@lowdefy/email-templates';` : `export const renderEmail = undefined;
+export const interpolateProperties = undefined;`;
+    await context.writeBuildArtifact('plugins/notifications.js', `${registry}
+${helperExports}
+`);
+}
+export default writeNotificationImports;

package/dist/build/writePluginImports/writeOperatorSchemaMap.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.
-*/ async function writeOperatorSchemaMap({ components, context }) {
+*/ import importPluginModule from './importPluginModule.js';
+async function writeOperatorSchemaMap({ components, context }) {
     const schemas = {};
     const typesMapSchemas = context.typesMap.schemas?.operators ?? {};
     const allOperators = new Map();
@@ -30,12 +31,10 @@
         operatorsByPackage[op.package].push(op);
     }
     for (const [packageName, operators] of Object.entries(operatorsByPackage)){
-        let packageSchemas;
-        try {
-            packageSchemas = await import(/* webpackIgnore: true */ `${packageName}/schemas`);
-        } catch  {
-        // Package not resolvable from build context (custom plugins) — skip
-        }
+        const packageSchemas = await importPluginModule({
+            context,
+            specifier: `${packageName}/schemas`
+        });
         for (const op of operators){
             if (typesMapSchemas[op.typeName]) {
                 schemas[op.typeName] = typesMapSchemas[op.typeName];

package/dist/build/writePluginImports/writePluginImports.js

@@ -16,14 +16,17 @@
 import writeActionSchemaMap from './writeActionSchemaMap.js';
 import writeAgentImports from './writeAgentImports.js';
 import writeAuthImports from './writeAuthImports.js';
+import writeAvailableTypes from './writeAvailableTypes.js';
 import writeBlockImports from './writeBlockImports.js';
 import writeBlockSchemaMap from './writeBlockSchemaMap.js';
 import writeConnectionImports from './writeConnectionImports.js';
+import writeConnectionSchemaMap from './writeConnectionSchemaMap.js';
 import writeIconImports from './writeIconImports.js';
+import writeNotificationImports from './writeNotificationImports.js';
 import writeOperatorImports from './writeOperatorImports.js';
 import writeOperatorSchemaMap from './writeOperatorSchemaMap.js';
+import writeWebsocketImports from './writeWebsocketImports.js';
 import writeGlobalsCss from './writeGlobalsCss.js';
-import writeServerExternalPackages from './writeServerExternalPackages.js';
 async function writePluginImports({ components, context }) {
     await writeActionImports({
         components,
@@ -53,10 +56,17 @@ async function writePluginImports({ components, context }) {
         components,
         context
     });
+    await writeConnectionSchemaMap({
+        context
+    });
     await writeIconImports({
         components,
         context
     });
+    await writeNotificationImports({
+        components,
+        context
+    });
     await writeOperatorImports({
         components,
         context
@@ -65,15 +75,19 @@ async function writePluginImports({ components, context }) {
         components,
         context
     });
-    await writeGlobalsCss({
+    await writeWebsocketImports({
         components,
         context
     });
-    await writeServerExternalPackages({
+    await writeAvailableTypes({
+        context
+    });
+    await writeGlobalsCss({
         components,
         context
     });
-    // Write block package names for Next.js transpilePackages (CSS imports).
+    // Write block package names — available as a vite.config.js escape hatch
+    // (optimizeDeps/noExternal lists) for packages that don't resolve cleanly.
     const blockPackages = [
         ...new Set((components.imports.blocks ?? []).map((b)=>b.package))
     ];

package/dist/build/writePluginImports/writeWebsocketImports.js

@@ -0,0 +1,22 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import generateImportFile from './generateImportFile.js';
+async function writeWebsocketImports({ components, context }) {
+    await context.writeBuildArtifact('plugins/websockets.js', generateImportFile({
+        imports: components.imports.websockets,
+        importPath: 'websockets'
+    }));
+}
+export default writeWebsocketImports;

package/dist/build/writeWebsockets.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, serializer } from '@lowdefy/helpers';
+async function writeWebsocket({ websocket, context }) {
+    await context.writeBuildArtifact(`websockets/${websocket.websocketId}.json`, serializer.serializeToString(websocket ?? {}));
+}
+async function writeWebsockets({ components, context }) {
+    if (type.isNone(components.websockets)) return;
+    if (!type.isArray(components.websockets)) {
+        throw new Error(`Websockets is not an array.`);
+    }
+    const writePromises = components.websockets.map((websocket)=>writeWebsocket({
+            websocket,
+            context
+        }));
+    return Promise.all(writePromises);
+}
+export default writeWebsockets;

package/dist/createContext.js

@@ -26,6 +26,8 @@ function createContext({ customMessagesMap, customTypesMap, directories, logger,
         defaultPackageNames: new Set(defaultPackages),
         agentIds: new Set(),
         connectionIds: new Set(),
+        notificationIds: new Set(),
+        websocketIds: new Set(),
         directories,
         errors: [],
         jsMap: {},
@@ -49,11 +51,14 @@ function createContext({ customMessagesMap, customTypesMap, directories, logger,
                 adapters: createCounter(),
                 callbacks: createCounter(),
                 events: createCounter(),
-                providers: createCounter()
+                providers: createCounter(),
+                strategies: createCounter()
             },
             blocks: createCounter(),
             connections: createCounter(),
+            notifications: createCounter(),
             requests: createCounter(),
+            websockets: createCounter(),
             controls: createCounter(),
             operators: {
                 client: createCounter('client'),

package/dist/defaultPackages.js

@@ -21,6 +21,7 @@
     '@lowdefy/blocks-basic',
     '@lowdefy/blocks-diff',
     '@lowdefy/blocks-echarts',
+    '@lowdefy/blocks-files',
     '@lowdefy/blocks-google-maps',
     '@lowdefy/blocks-loaders',
     '@lowdefy/blocks-markdown',
@@ -40,7 +41,9 @@
     '@lowdefy/connection-mongodb',
     '@lowdefy/connection-redis',
     '@lowdefy/connection-sendgrid',
+    '@lowdefy/connection-smtp',
     '@lowdefy/connection-stripe',
+    '@lowdefy/email-templates',
     '@lowdefy/operators-change-case',
     '@lowdefy/operators-diff',
     '@lowdefy/operators-js',
@@ -52,7 +55,10 @@
     '@lowdefy/operators-yaml',
     '@lowdefy/plugin-auth0',
     '@lowdefy/plugin-aws',
+    '@lowdefy/plugin-azure',
     '@lowdefy/plugin-csv',
-    '@lowdefy/plugin-next-auth'
+    '@lowdefy/plugin-gcp',
+    '@lowdefy/plugin-next-auth',
+    '@lowdefy/websockets-core'
 ];
 export default defaultPackages;