windmill-cli 1.589.3 → 1.591.0

package/esm/deps/jsr.io/@windmill-labs/shared-utils/{1.0.10 → 1.0.11}/lib.es.js

@@ -1305,7 +1305,7 @@ function computeS3FileInputPolicy(c, L) {
 function isPartialS3Object(c) {
     return typeof c == "object" && !!c && typeof c.s3 == "string";
 }
-function computeS3ImageViewerPolicy(c) {
+function computeS3FileViewerPolicy(c) {
     if (c.source.type === "uploadS3" && isPartialS3Object(c.source.value))
         return {
             s3_path: c.source.value.s3,
@@ -1400,9 +1400,9 @@ async function updatePolicy(c, L) {
         else
             return !1;
     }) !== -1 && V.push(computeWorkspaceS3FileInputPolicy());
-    let H = R.filter((c) => c.data.type === "imagecomponent").map((c) => {
+    let H = R.filter((c) => c.data.type === "imagecomponent" || c.data.type === "pdfcomponent" || c.data.type === "downloadcomponent").map((c) => {
         let L = c.data.configuration;
-        return computeS3ImageViewerPolicy(L);
+        return computeS3FileViewerPolicy(L);
     }).filter(Boolean);
     return {
         ...L ?? {},
@@ -1515,7 +1515,7 @@ async function processRunnable(c, L, R) {
                 allow_user_resources: B
             }];
 }
-var rawAppWmillTs_exports = /* @__PURE__ */ __export({ default: () => rawAppWmillTs_default }), rawAppWmillTs_default = "let reqs: Record<string, any> = {}\n\nfunction doRequest(type: string, o: object) {\n    return new Promise((resolve, reject) => {\n        const reqId = Math.random().toString(36)\n        reqs[reqId] = { resolve, reject }\n        parent.postMessage({ ...o, type, reqId }, '*')\n    })\n}\n\nexport const backend = new Proxy(\n    {},\n    {\n        get(_, runnable_id: string) {\n            return (v: any) => {\n                return doRequest('backend', { runnable_id, v })\n            }\n        }\n    })\n\nexport const backendAsync = new Proxy(\n    {},\n    {\n        get(_, runnable_id: string) {\n            return (v: any) => {\n                return doRequest('backendAsync', { runnable_id, v })\n            }\n        }\n    })\n\nexport function waitJob(jobId: string) {\n    return doRequest('waitJob', { jobId })\n}\n\nexport function getJob(jobId: string) {\n    return doRequest('getJob', { jobId })\n}\n\n\nwindow.addEventListener('message', (e) => {\n    if (e.data.type == 'runBgRes' || e.data.type == 'runBgAsyncRes') {\n        console.log('Message from parent backend', e.data)\n        let job = reqs[e.data.reqId]\n        if (job) {\n            const result = e.data.result\n            if (e.data.error) {\n                job.reject(new Error(result.stack ?? result.message))\n            } else {\n                job.resolve(result)\n            }\n        } else {\n            console.error('No job found for', e.data.reqId)\n        }\n    }\n})";
+var rawAppWmillTs_exports = /* @__PURE__ */ __export({ default: () => rawAppWmillTs_default }), rawAppWmillTs_default = "let reqs: Record<string, any> = {}\n\nfunction doRequest(type: string, o: object) {\n    return new Promise((resolve, reject) => {\n        const reqId = Math.random().toString(36)\n        reqs[reqId] = { resolve, reject }\n        parent.postMessage({ ...o, type, reqId }, '*')\n    })\n}\n\nexport const backend = new Proxy(\n    {},\n    {\n        get(_, runnable_id: string) {\n            return (v: any) => {\n                return doRequest('backend', { runnable_id, v })\n            }\n        }\n    })\n\nexport const backendAsync = new Proxy(\n    {},\n    {\n        get(_, runnable_id: string) {\n            return (v: any) => {\n                return doRequest('backendAsync', { runnable_id, v })\n            }\n        }\n    })\n\nexport function waitJob(jobId: string) {\n    return doRequest('waitJob', { jobId })\n}\n\nexport function getJob(jobId: string) {\n    return doRequest('getJob', { jobId })\n}\n\n\nwindow.addEventListener('message', (e) => {\n    if (e.data.type == 'backendRes' || e.data.type == 'backendAsyncRes') {\n        console.log('Message from parent backend', e.data)\n        let job = reqs[e.data.reqId]\n        if (job) {\n            const result = e.data.result\n            if (e.data.error) {\n                job.reject(new Error(result.stack ?? result.message))\n            } else {\n                job.resolve(result)\n            }\n        } else {\n            console.error('No job found for', e.data.reqId)\n        }\n    }\n})";
 function capitalize(c) {
     return c ? c.charAt(0).toUpperCase() + c.slice(1) : "";
 }

package/esm/deps.js

@@ -48,7 +48,7 @@ export { WebSocketServer, WebSocket } from "ws";
 export * as getPort from "get-port";
 export * as open from "open";
 export * as esMain from "es-main";
-export * as windmillUtils from "./deps/jsr.io/@windmill-labs/shared-utils/1.0.10/lib.es.js";
+export * as windmillUtils from "./deps/jsr.io/@windmill-labs/shared-utils/1.0.11/lib.es.js";
 import { OpenAPI } from "./gen/index.js";
 export function setClient(token, baseUrl) {
     if (baseUrl === undefined) {

package/esm/gen/core/OpenAPI.js

@@ -32,7 +32,7 @@ export const OpenAPI = {
     PASSWORD: undefined,
     TOKEN: getEnv("WM_TOKEN"),
     USERNAME: undefined,
-    VERSION: '1.589.3',
+    VERSION: '1.591.0',
     WITH_CREDENTIALS: true,
     interceptors: {
         request: new Interceptors(),

package/esm/gen/services.gen.js

@@ -34,6 +34,24 @@ export const getLicenseId = () => {
         url: '/ee_license'
     });
 };
+/**
+ * query Windmill AI documentation assistant (EE only)
+ * @param data The data for the request.
+ * @param data.requestBody query to send to the AI documentation assistant
+ * @returns unknown AI documentation assistant response
+ * @throws ApiError
+ */
+export const queryDocumentation = (data) => {
+    return __request(OpenAPI, {
+        method: 'POST',
+        url: '/inkeep',
+        body: data.requestBody,
+        mediaType: 'application/json',
+        errors: {
+            403: 'Enterprise Edition required'
+        }
+    });
+};
 /**
  * get openapi yaml spec
  * @returns string openapi yaml file content
@@ -569,30 +587,44 @@ export const existsUsername = (data) => {
     });
 };
 /**
- * Returns the set-up statuses of ducklake instance catalog dbs
- * @returns DucklakeInstanceCatalogDbStatus Statuses of all ducklake instance catalog dbs
+ * Refreshes the password for the custom_instance_user
+ * @returns unknown Success
  * @throws ApiError
  */
-export const getDucklakeInstanceCatalogDbStatus = () => {
+export const refreshCustomInstanceUserPwd = () => {
     return __request(OpenAPI, {
         method: 'POST',
-        url: '/settings/get_ducklake_instance_catalog_db_status'
+        url: '/settings/refresh_custom_instance_user_pwd'
     });
 };
 /**
- * Runs CREATE DATABASE on the Windmill Postgres and grants access to the ducklake_user
+ * Returns the set-up statuses of custom instance pg databases
+ * @returns CustomInstanceDb Statuses of all custom instance dbs
+ * @throws ApiError
+ */
+export const listCustomInstanceDbs = () => {
+    return __request(OpenAPI, {
+        method: 'POST',
+        url: '/settings/list_custom_instance_pg_databases'
+    });
+};
+/**
+ * Runs CREATE DATABASE on the Windmill Postgres and grants access to the custom_instance_user
  * @param data The data for the request.
  * @param data.name The name of the database to create
- * @returns DucklakeInstanceCatalogDbStatus status
+ * @param data.requestBody
+ * @returns CustomInstanceDb status
  * @throws ApiError
  */
-export const setupDucklakeCatalogDb = (data) => {
+export const setupCustomInstanceDb = (data) => {
     return __request(OpenAPI, {
         method: 'POST',
-        url: '/settings/setup_ducklake_catalog_db/{name}',
+        url: '/settings/setup_custom_instance_pg_database/{name}',
         path: {
             name: data.name
-        }
+        },
+        body: data.requestBody,
+        mediaType: 'application/json'
     });
 };
 /**
@@ -1891,6 +1923,22 @@ export const listDucklakes = (data) => {
         }
     });
 };
+/**
+ * list Datatables
+ * @param data The data for the request.
+ * @param data.workspace
+ * @returns string status
+ * @throws ApiError
+ */
+export const listDataTables = (data) => {
+    return __request(OpenAPI, {
+        method: 'GET',
+        url: '/w/{workspace}/workspaces/list_datatables',
+        path: {
+            workspace: data.workspace
+        }
+    });
+};
 /**
  * edit ducklake settings
  * @param data The data for the request.
@@ -1910,6 +1958,25 @@ export const editDucklakeConfig = (data) => {
         mediaType: 'application/json'
     });
 };
+/**
+ * edit datatable settings
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.requestBody DataTable settings
+ * @returns unknown status
+ * @throws ApiError
+ */
+export const editDataTableConfig = (data) => {
+    return __request(OpenAPI, {
+        method: 'POST',
+        url: '/w/{workspace}/workspaces/edit_datatable_config',
+        path: {
+            workspace: data.workspace
+        },
+        body: data.requestBody,
+        mediaType: 'application/json'
+    });
+};
 /**
  * edit workspace git sync settings
  * @param data The data for the request.
@@ -2306,6 +2373,7 @@ export const listTokens = (data = {}) => {
  * @param data The data for the request.
  * @param data.workspace
  * @param data.audience
+ * @param data.expiresIn
  * @returns string new oidc token
  * @throws ApiError
  */
@@ -2316,6 +2384,9 @@ export const getOidcToken = (data) => {
         path: {
             workspace: data.workspace,
             audience: data.audience
+        },
+        query: {
+            expires_in: data.expiresIn
         }
     });
 };
@@ -6108,6 +6179,25 @@ export const runScriptPreview = (data) => {
         mediaType: 'application/json'
     });
 };
+/**
+ * run script preview without starting a new job
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.requestBody preview
+ * @returns unknown script result
+ * @throws ApiError
+ */
+export const runScriptPreviewInline = (data) => {
+    return __request(OpenAPI, {
+        method: 'POST',
+        url: '/w/{workspace}/jobs/run_inline/preview',
+        path: {
+            workspace: data.workspace
+        },
+        body: data.requestBody,
+        mediaType: 'application/json'
+    });
+};
 /**
  * run script preview and wait for result
  * @param data The data for the request.
@@ -6253,6 +6343,8 @@ export const runDynamicSelect = (data) => {
  * @param data.scriptPathExact mask to filter exact matching path
  * @param data.scriptPathStart mask to filter matching starting path
  * @param data.schedulePath mask to filter by schedule path
+ * @param data.triggerPath mask to filter by trigger path
+ * @param data.triggerKind trigger kind (schedule, http, websocket...)
  * @param data.scriptHash mask to filter exact matching path
  * @param data.startedBefore filter on started before (inclusive) timestamp
  * @param data.startedAfter filter on started after (exclusive) timestamp
@@ -6287,6 +6379,8 @@ export const listQueue = (data) => {
             script_path_exact: data.scriptPathExact,
             script_path_start: data.scriptPathStart,
             schedule_path: data.schedulePath,
+            trigger_path: data.triggerPath,
+            trigger_kind: data.triggerKind,
             script_hash: data.scriptHash,
             started_before: data.startedBefore,
             started_after: data.startedAfter,
@@ -6535,6 +6629,52 @@ export const cancelSelection = (data) => {
         mediaType: 'application/json'
     });
 };
+/**
+ * resume all suspended jobs for a specific trigger
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.triggerKind The kind of trigger
+ * @param data.triggerPath The path of the trigger (can contain forward slashes)
+ * @param data.requestBody Optional list of job IDs to reassign
+ * @returns string confirmation message
+ * @throws ApiError
+ */
+export const resumeSuspendedTriggerJobs = (data) => {
+    return __request(OpenAPI, {
+        method: 'POST',
+        url: '/w/{workspace}/trigger/{trigger_kind}/resume_suspended_trigger_jobs/{trigger_path}',
+        path: {
+            workspace: data.workspace,
+            trigger_kind: data.triggerKind,
+            trigger_path: data.triggerPath
+        },
+        body: data.requestBody,
+        mediaType: 'application/json'
+    });
+};
+/**
+ * cancel all suspended jobs for a specific trigger
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.triggerKind The kind of trigger
+ * @param data.triggerPath The path of the trigger (can contain forward slashes)
+ * @param data.requestBody Optional list of job IDs to cancel
+ * @returns string confirmation message
+ * @throws ApiError
+ */
+export const cancelSuspendedTriggerJobs = (data) => {
+    return __request(OpenAPI, {
+        method: 'POST',
+        url: '/w/{workspace}/trigger/{trigger_kind}/cancel_suspended_trigger_jobs/{trigger_path}',
+        path: {
+            workspace: data.workspace,
+            trigger_kind: data.triggerKind,
+            trigger_path: data.triggerPath
+        },
+        body: data.requestBody,
+        mediaType: 'application/json'
+    });
+};
 /**
  * list all completed jobs
  * @param data The data for the request.
@@ -7941,10 +8081,10 @@ export const existsRoute = (data) => {
  * @returns string http trigger enable/disable
  * @throws ApiError
  */
-export const setHttpTriggerEnabled = (data) => {
+export const setHttpTriggerMode = (data) => {
     return __request(OpenAPI, {
         method: 'POST',
-        url: '/w/{workspace}/http_triggers/setenabled/{path}',
+        url: '/w/{workspace}/http_triggers/setmode/{path}',
         path: {
             workspace: data.workspace,
             path: data.path
@@ -8084,10 +8224,10 @@ export const existsWebsocketTrigger = (data) => {
  * @returns string websocket trigger enabled set
  * @throws ApiError
  */
-export const setWebsocketTriggerEnabled = (data) => {
+export const setWebsocketTriggerMode = (data) => {
     return __request(OpenAPI, {
         method: 'POST',
-        url: '/w/{workspace}/websocket_triggers/setenabled/{path}',
+        url: '/w/{workspace}/websocket_triggers/setmode/{path}',
         path: {
             workspace: data.workspace,
             path: data.path
@@ -8246,10 +8386,10 @@ export const existsKafkaTrigger = (data) => {
  * @returns string kafka trigger enabled set
  * @throws ApiError
  */
-export const setKafkaTriggerEnabled = (data) => {
+export const setKafkaTriggerMode = (data) => {
     return __request(OpenAPI, {
         method: 'POST',
-        url: '/w/{workspace}/kafka_triggers/setenabled/{path}',
+        url: '/w/{workspace}/kafka_triggers/setmode/{path}',
         path: {
             workspace: data.workspace,
             path: data.path
@@ -8408,10 +8548,10 @@ export const existsNatsTrigger = (data) => {
  * @returns string nats trigger enabled set
  * @throws ApiError
  */
-export const setNatsTriggerEnabled = (data) => {
+export const setNatsTriggerMode = (data) => {
     return __request(OpenAPI, {
         method: 'POST',
-        url: '/w/{workspace}/nats_triggers/setenabled/{path}',
+        url: '/w/{workspace}/nats_triggers/setmode/{path}',
         path: {
             workspace: data.workspace,
             path: data.path
@@ -8570,10 +8710,10 @@ export const existsSqsTrigger = (data) => {
  * @returns string sqs trigger enabled set
  * @throws ApiError
  */
-export const setSqsTriggerEnabled = (data) => {
+export const setSqsTriggerMode = (data) => {
     return __request(OpenAPI, {
         method: 'POST',
-        url: '/w/{workspace}/sqs_triggers/setenabled/{path}',
+        url: '/w/{workspace}/sqs_triggers/setmode/{path}',
         path: {
             workspace: data.workspace,
             path: data.path
@@ -8732,10 +8872,10 @@ export const existsMqttTrigger = (data) => {
  * @returns string mqtt trigger enabled set
  * @throws ApiError
  */
-export const setMqttTriggerEnabled = (data) => {
+export const setMqttTriggerMode = (data) => {
     return __request(OpenAPI, {
         method: 'POST',
-        url: '/w/{workspace}/mqtt_triggers/setenabled/{path}',
+        url: '/w/{workspace}/mqtt_triggers/setmode/{path}',
         path: {
             workspace: data.workspace,
             path: data.path
@@ -8894,10 +9034,10 @@ export const existsGcpTrigger = (data) => {
  * @returns string gcp trigger enabled set
  * @throws ApiError
  */
-export const setGcpTriggerEnabled = (data) => {
+export const setGcpTriggerMode = (data) => {
     return __request(OpenAPI, {
         method: 'POST',
-        url: '/w/{workspace}/gcp_triggers/setenabled/{path}',
+        url: '/w/{workspace}/gcp_triggers/setmode/{path}',
         path: {
             workspace: data.workspace,
             path: data.path
@@ -9353,10 +9493,10 @@ export const existsPostgresTrigger = (data) => {
  * @returns string postgres trigger enabled set
  * @throws ApiError
  */
-export const setPostgresTriggerEnabled = (data) => {
+export const setPostgresTriggerMode = (data) => {
     return __request(OpenAPI, {
         method: 'POST',
-        url: '/w/{workspace}/postgres_triggers/setenabled/{path}',
+        url: '/w/{workspace}/postgres_triggers/setmode/{path}',
         path: {
             workspace: data.workspace,
             path: data.path
@@ -9534,10 +9674,10 @@ export const existsEmailLocalPart = (data) => {
  * @returns string email trigger enable/disable
  * @throws ApiError
  */
-export const setEmailTriggerEnabled = (data) => {
+export const setEmailTriggerMode = (data) => {
     return __request(OpenAPI, {
         method: 'POST',
-        url: '/w/{workspace}/email_triggers/setenabled/{path}',
+        url: '/w/{workspace}/email_triggers/setmode/{path}',
         path: {
             workspace: data.workspace,
             path: data.path

package/esm/src/commands/app/app_metadata.js

@@ -7,8 +7,9 @@ import { workspaceDependenciesLanguages, } from "../../utils/script_common.js";
 import { generateHash, getHeaders, writeIfChanged } from "../../utils/utils.js";
 import { exts } from "../script/script.js";
 import { FSFSElement, yamlOptions } from "../sync/sync.js";
+import { loadRunnablesFromBackend, writeRunnableToBackend, } from "./raw_apps.js";
 import { replaceInlineScripts } from "./apps.js";
-import { newPathAssigner, } from "../../../windmill-utils-internal/src/path-utils/path-assigner.js";
+import { newPathAssigner, newRawAppPathAssigner, } from "../../../windmill-utils-internal/src/path-utils/path-assigner.js";
 import { mergeConfigWithConfigFile } from "../../core/conf.js";
 import { resolveWorkspace } from "../../core/context.js";
 import { requireLogin } from "../../core/auth.js";
@@ -88,12 +89,19 @@ export async function generateAppLocksInternal(appFolder, rawApp, dryRun, worksp
         if (changedScripts.length > 0) {
             log.info(`Recomputing locks of ${changedScripts.join(", ")} in ${appFolder}`);
             if (rawApp) {
-                const runnablesPath = path.join(appFolder, APP_BACKEND_FOLDER) + SEP;
+                const runnablesPath = path.join(appFolder, APP_BACKEND_FOLDER);
+                // Load runnables from separate files (new format) or fall back to raw_app.yaml (old format)
                 const rawAppFile = appFile;
+                let runnables = await loadRunnablesFromBackend(runnablesPath);
+                if (Object.keys(runnables).length === 0 && rawAppFile.runnables) {
+                    // Fall back to old format
+                    runnables = rawAppFile.runnables;
+                }
                 // Replace inline scripts for changed runnables
-                replaceInlineScripts(rawAppFile.runnables, runnablesPath, false);
-                // Update the app runnables with new locks
-                rawAppFile.runnables = await updateRawAppRunnables(workspace, rawAppFile.runnables, remote_path, appFolder, rawWorkspaceDependencies, opts.defaultTs);
+                replaceInlineScripts(runnables, runnablesPath + SEP, false);
+                // Update the app runnables with new locks (writes to separate files)
+                await updateRawAppRunnables(workspace, runnables, remote_path, appFolder, rawWorkspaceDependencies, opts.defaultTs);
+                // Note: updateRawAppRunnables now writes each runnable to its own file
             }
             else {
                 const normalAppFile = appFile;
@@ -101,9 +109,9 @@ export async function generateAppLocksInternal(appFolder, rawApp, dryRun, worksp
                 replaceInlineScripts(normalAppFile.value, appFolder + SEP, false);
                 // Update the app value with new locks
                 normalAppFile.value = await updateAppInlineScripts(workspace, normalAppFile.value, remote_path, appFolder, rawWorkspaceDependencies, opts.defaultTs);
+                // Write the updated app file (only for normal apps, raw apps use separate files)
+                writeIfChanged(appFilePath, yamlStringify(appFile, yamlOptions));
             }
-            // Write the updated app file
-            writeIfChanged(appFilePath, yamlStringify(appFile, yamlOptions));
         }
         else {
             log.info(colors.gray(`No scripts changed in ${appFolder}`));
@@ -152,8 +160,9 @@ async function traverseAndProcessInlineScripts(obj, processor, currentPath = [])
     return result;
 }
 /**
- * Updates locks for all runnables in a raw app, generating locks inline script by inline script
- * Also writes content and locks back to the runnables folder
+ * Updates locks for all runnables in a raw app, generating locks inline script by inline script.
+ * Writes each runnable to its own YAML file in the backend folder (new format).
+ * Also writes content and lock files to the runnables folder.
  */
 async function updateRawAppRunnables(workspace, runnables, remotePath, appFolder, rawDeps, defaultTs = "bun") {
     const runnablesFolder = path.join(appFolder, APP_BACKEND_FOLDER);
@@ -164,31 +173,44 @@ async function updateRawAppRunnables(workspace, runnables, remotePath, appFolder
     catch {
         // Folder may already exist
     }
-    const pathAssigner = newPathAssigner(defaultTs);
-    // Process each runnable
-    const updatedRunnables = {};
+    const pathAssigner = newRawAppPathAssigner(defaultTs);
     for (const [runnableId, runnable] of Object.entries(runnables)) {
-        // Only process inline scripts (runnableByName with inlineScript)
-        if (runnable?.type !== "runnableByName" || !runnable?.inlineScript) {
-            updatedRunnables[runnableId] = runnable;
+        // Only process inline scripts (runnableByName/inline with inlineScript)
+        if ((runnable?.type !== "runnableByName" && runnable?.type !== "inline") ||
+            !runnable?.inlineScript) {
+            // Write non-inline runnables to their own file as-is
+            writeRunnableToBackend(runnablesFolder, runnableId, runnable);
             continue;
         }
         const inlineScript = runnable.inlineScript;
         const language = inlineScript.language;
         const content = inlineScript.content;
         if (!content || !language) {
-            updatedRunnables[runnableId] = runnable;
+            writeRunnableToBackend(runnablesFolder, runnableId, runnable);
             continue;
         }
         // Skip if content is still an !inline reference (should have been replaced by replaceInlineScripts)
         if (typeof content === "string" && content.startsWith("!inline ")) {
             log.warn(colors.yellow(`Runnable ${runnableId} content is still an !inline reference, skipping`));
-            updatedRunnables[runnableId] = runnable;
+            writeRunnableToBackend(runnablesFolder, runnableId, runnable);
             continue;
         }
         // Skip frontend scripts - they don't need locks
         if (language === "frontend") {
-            updatedRunnables[runnableId] = runnable;
+            // Still need to write the runnable YAML file
+            const [basePathO, ext] = pathAssigner.assignPath(runnable.name ?? runnableId, language);
+            const basePath = basePathO.replaceAll(SEP, "/");
+            const contentPath = path.join(runnablesFolder, `${basePath}${ext}`);
+            writeIfChanged(contentPath, content);
+            // Write simplified runnable YAML - just type: 'inline' plus metadata
+            // inlineScript is not needed since content/language can be derived from files
+            const simplifiedRunnable = { type: "inline" };
+            for (const [key, value] of Object.entries(runnable)) {
+                if (key !== "inlineScript" && key !== "type") {
+                    simplifiedRunnable[key] = value;
+                }
+            }
+            writeRunnableToBackend(runnablesFolder, runnableId, simplifiedRunnable);
             continue;
         }
         log.info(colors.gray(`Generating lock for runnable ${runnableId} (${language})
@@ -196,7 +218,7 @@ async function updateRawAppRunnables(workspace, runnables, remotePath, appFolder
         try {
             const lock = await generateInlineScriptLock(workspace, content, language, `${remotePath}/${runnableId}`, rawDeps);
             // Determine file extension for this language
-            const [basePathO, ext] = pathAssigner.assignPath(runnable.name, language);
+            const [basePathO, ext] = pathAssigner.assignPath(runnable.name ?? runnableId, language);
             const basePath = basePathO.replaceAll(SEP, "/");
             const contentPath = path.join(runnablesFolder, `${basePath}${ext}`);
             const lockPath = path.join(runnablesFolder, `${basePath}lock`);
@@ -206,26 +228,24 @@ async function updateRawAppRunnables(workspace, runnables, remotePath, appFolder
             if (lock && lock !== "") {
                 writeIfChanged(lockPath, lock);
             }
-            // Update the runnable with !inline references (preserve existing schema)
-            const inlineContentRef = `!inline ${basePath}${ext}`;
-            const inlineLockRef = lock && lock !== "" ? `!inline ${basePath}lock` : "";
-            updatedRunnables[runnableId] = {
-                ...runnable,
-                inlineScript: {
-                    ...inlineScript,
-                    content: inlineContentRef,
-                    lock: inlineLockRef,
-                },
-            };
-            log.info(colors.gray(`  Written ${basePath}${ext}${lock ? ` and ${basePath}lock` : ""}`));
+            // Write simplified runnable YAML - just type: 'inline' plus metadata
+            // inlineScript is not needed since content/lock/language can be derived from files
+            const simplifiedRunnable = { type: "inline" };
+            for (const [key, value] of Object.entries(runnable)) {
+                if (key !== "inlineScript" && key !== "type") {
+                    simplifiedRunnable[key] = value;
+                }
+            }
+            // Write the runnable to its own YAML file
+            writeRunnableToBackend(runnablesFolder, runnableId, simplifiedRunnable);
+            log.info(colors.gray(`  Written ${runnableId}.yaml, ${basePath}${ext}${lock ? ` and ${basePath}lock` : ""}`));
         }
         catch (error) {
             log.error(colors.red(`Failed to generate lock for runnable ${runnableId}: ${error.message}`));
-            // Continue with other runnables even if one fails
-            updatedRunnables[runnableId] = runnable;
+            // Write the original runnable even if lock generation fails
+            writeRunnableToBackend(runnablesFolder, runnableId, runnable);
         }
     }
-    return updatedRunnables;
 }
 /**
  * Updates locks for all inline scripts in a normal app, similar to updateRawAppRunnables
@@ -334,33 +354,47 @@ async function generateInlineScriptLock(workspace, content, language, scriptPath
 /**
  * Infers schema for a single runnable from its file content.
  * Used by dev server to update schema in memory (for wmill.d.ts generation).
- * Does NOT write to raw_app.yaml - schema is kept in memory only.
+ * Does NOT write to the runnable YAML file - schema is kept in memory only.
  *
  * @param appFolder - The folder containing the raw app
  * @param runnableFilePath - The path to the changed runnable file (relative to runnables folder)
  * @returns The runnable ID and inferred schema, or undefined if inference failed/not applicable
  */
 export async function inferRunnableSchemaFromFile(appFolder, runnableFilePath) {
-    // Extract runnable ID from file path (e.g., "myRunnable.inline_script.ts" -> "myRunnable")
+    // Extract runnable ID from file path (e.g., "myRunnable.ts" -> "myRunnable")
     const fileName = path.basename(runnableFilePath);
-    // Skip lock files
-    if (fileName.endsWith(".lock")) {
+    // Skip lock files and yaml files (runnable metadata)
+    if (fileName.endsWith(".lock") || fileName.endsWith(".yaml")) {
         return undefined;
     }
-    // Match pattern: {runnableId}.inline_script.{ext}
-    const match = fileName.match(/^(.+)\.inline_script\.[^.]+$/);
+    // Match pattern: {runnableId}.{ext} - extract the runnable ID (everything before the last dot)
+    const match = fileName.match(/^(.+)\.[^.]+$/);
     if (!match) {
         return undefined;
     }
     const runnableId = match[1];
-    // Read the app file to get the language
-    const appFilePath = path.join(appFolder, "raw_app.yaml");
-    const appFile = (await yamlParseFile(appFilePath));
-    if (!appFile.runnables?.[runnableId]) {
-        log.warn(colors.yellow(`Runnable ${runnableId} not found in raw_app.yaml`));
-        return undefined;
+    // Read the runnable from its separate YAML file (new format)
+    const runnableFilePath2 = path.join(appFolder, APP_BACKEND_FOLDER, `${runnableId}.yaml`);
+    let runnable;
+    try {
+        runnable = await yamlParseFile(runnableFilePath2);
+    }
+    catch {
+        // Fall back to reading from raw_app.yaml (old format)
+        try {
+            const appFilePath = path.join(appFolder, "raw_app.yaml");
+            const appFile = (await yamlParseFile(appFilePath));
+            if (!appFile.runnables?.[runnableId]) {
+                log.warn(colors.yellow(`Runnable ${runnableId} not found in backend folder or raw_app.yaml`));
+                return undefined;
+            }
+            runnable = appFile.runnables[runnableId];
+        }
+        catch {
+            log.warn(colors.yellow(`Could not read runnable ${runnableId} from any source`));
+            return undefined;
+        }
     }
-    const runnable = appFile.runnables[runnableId];
     // Only process inline scripts
     if (!runnable?.inlineScript) {
         return undefined;

package/esm/src/commands/app/apps.js

@@ -6,6 +6,7 @@ import * as wmill from "../../../gen/services.gen.js";
 import { isSuperset } from "../../types.js";
 import { readInlinePathSync } from "../../utils/utils.js";
 import devCommand from "./dev.js";
+import lintCommand from "./lint.js";
 import { isVersionsGeq1585 } from "../sync/global.js";
 const alreadySynced = [];
 function respecializeFields(fields) {
@@ -190,6 +191,7 @@ const command = new Command()
     .arguments("<file_path:string> <remote_path:string>")
     .action(push)
     .command("dev", devCommand)
+    .command("lint", lintCommand)
     .command("generate-locks", "re-generate the lockfiles for app runnables inline scripts that have changed")
     .arguments("[app_folder:string]")
     .option("--yes", "Skip confirmation prompt")

package/esm/src/commands/app/bundle.js

@@ -168,8 +168,12 @@ export async function createBundle(options = {}) {
     const wmillPlugin = {
         name: "wmill-virtual",
         setup(build) {
-            // Intercept imports of /wmill.ts, /wmill, ./wmill.ts, or ./wmill
-            build.onResolve({ filter: /^(\.\/|\/)?wmill(\.ts)?$/ }, (args) => {
+            // Intercept imports of wmill with various path formats:
+            // - wmill, wmill.ts (bare import)
+            // - /wmill, /wmill.ts (absolute)
+            // - ./wmill, ./wmill.ts (same directory)
+            // - ../wmill, ../../wmill, etc. (parent directories)
+            build.onResolve({ filter: /^(\.\.\/)+wmill(\.ts)?$|^(\.\/|\/)?wmill(\.ts)?$/ }, (args) => {
                 log.info(colors.yellow(`[wmill-virtual] Intercepted: ${args.path}`));
                 return {
                     path: args.path,