elit 3.5.3 → 3.5.4

package/dist/cli.js

@@ -936,10 +936,10 @@ var init_http = __esm({
       }
       async text() {
         if (isNode) {
-          return new Promise((resolve8, reject) => {
+          return new Promise((resolve9, reject) => {
             const chunks = [];
             this._req.on("data", (chunk) => chunks.push(chunk));
-            this._req.on("end", () => resolve8(Buffer.concat(chunks).toString("utf8")));
+            this._req.on("end", () => resolve9(Buffer.concat(chunks).toString("utf8")));
             this._req.on("error", reject);
           });
         }
@@ -1083,8 +1083,8 @@ var init_http = __esm({
         }
         return this;
       }
-      _setResolver(resolve8) {
-        this._resolve = resolve8;
+      _setResolver(resolve9) {
+        this._resolve = resolve9;
       }
       // Express.js-like methods
       json(data, statusCode = 200) {
@@ -1290,12 +1290,12 @@ var init_http = __esm({
                   headers
                 });
               }
-              return new Promise((resolve8) => {
+              return new Promise((resolve9) => {
                 serverResponse.end = (chunk) => {
                   if (chunk !== void 0) {
                     body += chunk;
                   }
-                  resolve8(new Response(body, {
+                  resolve9(new Response(body, {
                     status: statusCode,
                     statusText: statusMessage,
                     headers
@@ -1311,10 +1311,10 @@ var init_http = __esm({
             port,
             hostname,
             handler: (req) => {
-              return new Promise((resolve8) => {
+              return new Promise((resolve9) => {
                 const incomingMessage = new IncomingMessage(req);
                 const serverResponse = new ServerResponse();
-                serverResponse._setResolver(resolve8);
+                serverResponse._setResolver(resolve9);
                 if (self2.requestListener) {
                   self2.requestListener(incomingMessage, serverResponse);
                 } else {
@@ -25175,11 +25175,11 @@ var require_scope = __commonJS({
     "use strict";
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve8) {
-          resolve8(value);
+        return value instanceof P ? value : new P(function(resolve9) {
+          resolve9(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve8, reject) {
+      return new (P || (P = Promise))(function(resolve9, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -25195,7 +25195,7 @@ var require_scope = __commonJS({
           }
         }
         function step(result2) {
-          result2.done ? resolve8(result2.value) : adopt(result2.value).then(fulfilled, rejected);
+          result2.done ? resolve9(result2.value) : adopt(result2.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -25486,11 +25486,11 @@ var require_instantiation = __commonJS({
     };
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve8) {
-          resolve8(value);
+        return value instanceof P ? value : new P(function(resolve9) {
+          resolve9(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve8, reject) {
+      return new (P || (P = Promise))(function(resolve9, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -25506,7 +25506,7 @@ var require_instantiation = __commonJS({
           }
         }
         function step(result2) {
-          result2.done ? resolve8(result2.value) : adopt(result2.value).then(fulfilled, rejected);
+          result2.done ? resolve9(result2.value) : adopt(result2.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -25761,11 +25761,11 @@ var require_resolver = __commonJS({
     };
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve9) {
-          resolve9(value);
+        return value instanceof P ? value : new P(function(resolve10) {
+          resolve10(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve9, reject) {
+      return new (P || (P = Promise))(function(resolve10, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -25781,7 +25781,7 @@ var require_resolver = __commonJS({
           }
         }
         function step(result2) {
-          result2.done ? resolve9(result2.value) : adopt(result2.value).then(fulfilled, rejected);
+          result2.done ? resolve10(result2.value) : adopt(result2.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -25856,7 +25856,7 @@ var require_resolver = __commonJS({
       }
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.resolve = resolve8;
+    exports2.resolve = resolve9;
     var ERROR_MSGS = __importStar(require_error_msgs());
     var literal_types_1 = require_literal_types();
     var planner_1 = require_planner();
@@ -26023,7 +26023,7 @@ var require_resolver = __commonJS({
       };
       return containersIterator;
     };
-    function resolve8(context) {
+    function resolve9(context) {
       var resolveRequestFunction = _resolveRequest(context.plan.rootRequest.requestScope);
       return resolveRequestFunction(context.plan.rootRequest);
     }
@@ -26818,11 +26818,11 @@ var require_container = __commonJS({
     };
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve8) {
-          resolve8(value);
+        return value instanceof P ? value : new P(function(resolve9) {
+          resolve9(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve8, reject) {
+      return new (P || (P = Promise))(function(resolve9, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -26838,7 +26838,7 @@ var require_container = __commonJS({
           }
         }
         function step(result2) {
-          result2.done ? resolve8(result2.value) : adopt(result2.value).then(fulfilled, rejected);
+          result2.done ? resolve9(result2.value) : adopt(result2.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -29201,7 +29201,7 @@ var require_escodegen = __commonJS({
       function noEmptySpace() {
         return space ? space : " ";
       }
-      function join7(left, right) {
+      function join8(left, right) {
         var leftSource, rightSource, leftCharCode, rightCharCode;
         leftSource = toSourceNodeWhenNeeded(left).toString();
         if (leftSource.length === 0) {
@@ -29536,8 +29536,8 @@ var require_escodegen = __commonJS({
           } else {
             result2.push(that.generateExpression(stmt.left, Precedence.Call, E_TTT));
           }
-          result2 = join7(result2, operator);
-          result2 = [join7(
+          result2 = join8(result2, operator);
+          result2 = [join8(
             result2,
             that.generateExpression(stmt.right, Precedence.Assignment, E_TTT)
           ), ")"];
@@ -29680,11 +29680,11 @@ var require_escodegen = __commonJS({
           var result2, fragment;
           result2 = ["class"];
           if (stmt.id) {
-            result2 = join7(result2, this.generateExpression(stmt.id, Precedence.Sequence, E_TTT));
+            result2 = join8(result2, this.generateExpression(stmt.id, Precedence.Sequence, E_TTT));
           }
           if (stmt.superClass) {
-            fragment = join7("extends", this.generateExpression(stmt.superClass, Precedence.Unary, E_TTT));
-            result2 = join7(result2, fragment);
+            fragment = join8("extends", this.generateExpression(stmt.superClass, Precedence.Unary, E_TTT));
+            result2 = join8(result2, fragment);
           }
           result2.push(space);
           result2.push(this.generateStatement(stmt.body, S_TFFT));
@@ -29697,9 +29697,9 @@ var require_escodegen = __commonJS({
           return escapeDirective(stmt.directive) + this.semicolon(flags);
         },
         DoWhileStatement: function(stmt, flags) {
-          var result2 = join7("do", this.maybeBlock(stmt.body, S_TFFF));
+          var result2 = join8("do", this.maybeBlock(stmt.body, S_TFFF));
           result2 = this.maybeBlockSuffix(stmt.body, result2);
-          return join7(result2, [
+          return join8(result2, [
             "while" + space + "(",
             this.generateExpression(stmt.test, Precedence.Sequence, E_TTT),
             ")" + this.semicolon(flags)
@@ -29735,11 +29735,11 @@ var require_escodegen = __commonJS({
         ExportDefaultDeclaration: function(stmt, flags) {
           var result2 = ["export"], bodyFlags;
           bodyFlags = flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF;
-          result2 = join7(result2, "default");
+          result2 = join8(result2, "default");
           if (isStatement(stmt.declaration)) {
-            result2 = join7(result2, this.generateStatement(stmt.declaration, bodyFlags));
+            result2 = join8(result2, this.generateStatement(stmt.declaration, bodyFlags));
           } else {
-            result2 = join7(result2, this.generateExpression(stmt.declaration, Precedence.Assignment, E_TTT) + this.semicolon(flags));
+            result2 = join8(result2, this.generateExpression(stmt.declaration, Precedence.Assignment, E_TTT) + this.semicolon(flags));
           }
           return result2;
         },
@@ -29747,15 +29747,15 @@ var require_escodegen = __commonJS({
           var result2 = ["export"], bodyFlags, that = this;
           bodyFlags = flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF;
           if (stmt.declaration) {
-            return join7(result2, this.generateStatement(stmt.declaration, bodyFlags));
+            return join8(result2, this.generateStatement(stmt.declaration, bodyFlags));
           }
           if (stmt.specifiers) {
             if (stmt.specifiers.length === 0) {
-              result2 = join7(result2, "{" + space + "}");
+              result2 = join8(result2, "{" + space + "}");
             } else if (stmt.specifiers[0].type === Syntax.ExportBatchSpecifier) {
-              result2 = join7(result2, this.generateExpression(stmt.specifiers[0], Precedence.Sequence, E_TTT));
+              result2 = join8(result2, this.generateExpression(stmt.specifiers[0], Precedence.Sequence, E_TTT));
             } else {
-              result2 = join7(result2, "{");
+              result2 = join8(result2, "{");
               withIndent(function(indent6) {
                 var i, iz;
                 result2.push(newline);
@@ -29773,7 +29773,7 @@ var require_escodegen = __commonJS({
               result2.push(base + "}");
             }
             if (stmt.source) {
-              result2 = join7(result2, [
+              result2 = join8(result2, [
                 "from" + space,
                 // ModuleSpecifier
                 this.generateExpression(stmt.source, Precedence.Sequence, E_TTT),
@@ -29793,7 +29793,7 @@ var require_escodegen = __commonJS({
           if (stmt.exported) {
             result2.push("as " + stmt.exported.name + " ");
           }
-          result2 = join7(result2, [
+          result2 = join8(result2, [
             "from" + space,
             // ModuleSpecifier
             this.generateExpression(stmt.source, Precedence.Sequence, E_TTT),
@@ -29867,7 +29867,7 @@ var require_escodegen = __commonJS({
           ];
           cursor = 0;
           if (stmt.specifiers[cursor].type === Syntax.ImportDefaultSpecifier) {
-            result2 = join7(result2, [
+            result2 = join8(result2, [
               this.generateExpression(stmt.specifiers[cursor], Precedence.Sequence, E_TTT)
             ]);
             ++cursor;
@@ -29877,7 +29877,7 @@ var require_escodegen = __commonJS({
               result2.push(",");
             }
             if (stmt.specifiers[cursor].type === Syntax.ImportNamespaceSpecifier) {
-              result2 = join7(result2, [
+              result2 = join8(result2, [
                 space,
                 this.generateExpression(stmt.specifiers[cursor], Precedence.Sequence, E_TTT)
               ]);
@@ -29906,7 +29906,7 @@ var require_escodegen = __commonJS({
               }
             }
           }
-          result2 = join7(result2, [
+          result2 = join8(result2, [
             "from" + space,
             // ModuleSpecifier
             this.generateExpression(stmt.source, Precedence.Sequence, E_TTT),
@@ -29966,7 +29966,7 @@ var require_escodegen = __commonJS({
           ];
         },
         ThrowStatement: function(stmt, flags) {
-          return [join7(
+          return [join8(
             "throw",
             this.generateExpression(stmt.argument, Precedence.Sequence, E_TTT)
           ), this.semicolon(flags)];
@@ -29977,7 +29977,7 @@ var require_escodegen = __commonJS({
           result2 = this.maybeBlockSuffix(stmt.block, result2);
           if (stmt.handlers) {
             for (i = 0, iz = stmt.handlers.length; i < iz; ++i) {
-              result2 = join7(result2, this.generateStatement(stmt.handlers[i], S_TFFF));
+              result2 = join8(result2, this.generateStatement(stmt.handlers[i], S_TFFF));
               if (stmt.finalizer || i + 1 !== iz) {
                 result2 = this.maybeBlockSuffix(stmt.handlers[i].body, result2);
               }
@@ -29985,7 +29985,7 @@ var require_escodegen = __commonJS({
           } else {
             guardedHandlers = stmt.guardedHandlers || [];
             for (i = 0, iz = guardedHandlers.length; i < iz; ++i) {
-              result2 = join7(result2, this.generateStatement(guardedHandlers[i], S_TFFF));
+              result2 = join8(result2, this.generateStatement(guardedHandlers[i], S_TFFF));
               if (stmt.finalizer || i + 1 !== iz) {
                 result2 = this.maybeBlockSuffix(guardedHandlers[i].body, result2);
               }
@@ -29993,13 +29993,13 @@ var require_escodegen = __commonJS({
             if (stmt.handler) {
               if (Array.isArray(stmt.handler)) {
                 for (i = 0, iz = stmt.handler.length; i < iz; ++i) {
-                  result2 = join7(result2, this.generateStatement(stmt.handler[i], S_TFFF));
+                  result2 = join8(result2, this.generateStatement(stmt.handler[i], S_TFFF));
                   if (stmt.finalizer || i + 1 !== iz) {
                     result2 = this.maybeBlockSuffix(stmt.handler[i].body, result2);
                   }
                 }
               } else {
-                result2 = join7(result2, this.generateStatement(stmt.handler, S_TFFF));
+                result2 = join8(result2, this.generateStatement(stmt.handler, S_TFFF));
                 if (stmt.finalizer) {
                   result2 = this.maybeBlockSuffix(stmt.handler.body, result2);
                 }
@@ -30007,7 +30007,7 @@ var require_escodegen = __commonJS({
             }
           }
           if (stmt.finalizer) {
-            result2 = join7(result2, ["finally", this.maybeBlock(stmt.finalizer, S_TFFF)]);
+            result2 = join8(result2, ["finally", this.maybeBlock(stmt.finalizer, S_TFFF)]);
           }
           return result2;
         },
@@ -30041,7 +30041,7 @@ var require_escodegen = __commonJS({
           withIndent(function() {
             if (stmt.test) {
               result2 = [
-                join7("case", that.generateExpression(stmt.test, Precedence.Sequence, E_TTT)),
+                join8("case", that.generateExpression(stmt.test, Precedence.Sequence, E_TTT)),
                 ":"
               ];
             } else {
@@ -30089,9 +30089,9 @@ var require_escodegen = __commonJS({
             result2.push(this.maybeBlock(stmt.consequent, S_TFFF));
             result2 = this.maybeBlockSuffix(stmt.consequent, result2);
             if (stmt.alternate.type === Syntax.IfStatement) {
-              result2 = join7(result2, ["else ", this.generateStatement(stmt.alternate, bodyFlags)]);
+              result2 = join8(result2, ["else ", this.generateStatement(stmt.alternate, bodyFlags)]);
             } else {
-              result2 = join7(result2, join7("else", this.maybeBlock(stmt.alternate, bodyFlags)));
+              result2 = join8(result2, join8("else", this.maybeBlock(stmt.alternate, bodyFlags)));
             }
           } else {
             result2.push(this.maybeBlock(stmt.consequent, bodyFlags));
@@ -30192,7 +30192,7 @@ var require_escodegen = __commonJS({
         },
         ReturnStatement: function(stmt, flags) {
           if (stmt.argument) {
-            return [join7(
+            return [join8(
               "return",
               this.generateExpression(stmt.argument, Precedence.Sequence, E_TTT)
             ), this.semicolon(flags)];
@@ -30297,14 +30297,14 @@ var require_escodegen = __commonJS({
           if (leftSource.charCodeAt(leftSource.length - 1) === 47 && esutils.code.isIdentifierPartES5(expr.operator.charCodeAt(0))) {
             result2 = [fragment, noEmptySpace(), expr.operator];
           } else {
-            result2 = join7(fragment, expr.operator);
+            result2 = join8(fragment, expr.operator);
           }
           fragment = this.generateExpression(expr.right, rightPrecedence, flags);
           if (expr.operator === "/" && fragment.toString().charAt(0) === "/" || expr.operator.slice(-1) === "<" && fragment.toString().slice(0, 3) === "!--") {
             result2.push(noEmptySpace());
             result2.push(fragment);
           } else {
-            result2 = join7(result2, fragment);
+            result2 = join8(result2, fragment);
           }
           if (expr.operator === "in" && !(flags & F_ALLOW_IN)) {
             return ["(", result2, ")"];
@@ -30343,7 +30343,7 @@ var require_escodegen = __commonJS({
           var result2, length2, i, iz, itemFlags;
           length2 = expr["arguments"].length;
           itemFlags = flags & F_ALLOW_UNPARATH_NEW && !parentheses && length2 === 0 ? E_TFT : E_TFF;
-          result2 = join7(
+          result2 = join8(
             "new",
             this.generateExpression(expr.callee, Precedence.New, itemFlags)
           );
@@ -30393,11 +30393,11 @@ var require_escodegen = __commonJS({
           var result2, fragment, rightCharCode, leftSource, leftCharCode;
           fragment = this.generateExpression(expr.argument, Precedence.Unary, E_TTT);
           if (space === "") {
-            result2 = join7(expr.operator, fragment);
+            result2 = join8(expr.operator, fragment);
           } else {
             result2 = [expr.operator];
             if (expr.operator.length > 2) {
-              result2 = join7(result2, fragment);
+              result2 = join8(result2, fragment);
             } else {
               leftSource = toSourceNodeWhenNeeded(result2).toString();
               leftCharCode = leftSource.charCodeAt(leftSource.length - 1);
@@ -30420,7 +30420,7 @@ var require_escodegen = __commonJS({
             result2 = "yield";
           }
           if (expr.argument) {
-            result2 = join7(
+            result2 = join8(
               result2,
               this.generateExpression(expr.argument, Precedence.Yield, E_TTT)
             );
@@ -30428,7 +30428,7 @@ var require_escodegen = __commonJS({
           return parenthesize(result2, Precedence.Yield, precedence);
         },
         AwaitExpression: function(expr, precedence, flags) {
-          var result2 = join7(
+          var result2 = join8(
             expr.all ? "await*" : "await",
             this.generateExpression(expr.argument, Precedence.Await, E_TTT)
           );
@@ -30511,11 +30511,11 @@ var require_escodegen = __commonJS({
           var result2, fragment;
           result2 = ["class"];
           if (expr.id) {
-            result2 = join7(result2, this.generateExpression(expr.id, Precedence.Sequence, E_TTT));
+            result2 = join8(result2, this.generateExpression(expr.id, Precedence.Sequence, E_TTT));
           }
           if (expr.superClass) {
-            fragment = join7("extends", this.generateExpression(expr.superClass, Precedence.Unary, E_TTT));
-            result2 = join7(result2, fragment);
+            fragment = join8("extends", this.generateExpression(expr.superClass, Precedence.Unary, E_TTT));
+            result2 = join8(result2, fragment);
           }
           result2.push(space);
           result2.push(this.generateStatement(expr.body, S_TFFT));
@@ -30530,7 +30530,7 @@ var require_escodegen = __commonJS({
           }
           if (expr.kind === "get" || expr.kind === "set") {
             fragment = [
-              join7(expr.kind, this.generatePropertyKey(expr.key, expr.computed)),
+              join8(expr.kind, this.generatePropertyKey(expr.key, expr.computed)),
               this.generateFunctionBody(expr.value)
             ];
           } else {
@@ -30540,7 +30540,7 @@ var require_escodegen = __commonJS({
               this.generateFunctionBody(expr.value)
             ];
           }
-          return join7(result2, fragment);
+          return join8(result2, fragment);
         },
         PrivateIdentifier: function(expr, precedence, flags) {
           return generateIdentifier(expr);
@@ -30753,7 +30753,7 @@ var require_escodegen = __commonJS({
               for (i = 0, iz = expr.blocks.length; i < iz; ++i) {
                 fragment = that.generateExpression(expr.blocks[i], Precedence.Sequence, E_TTT);
                 if (i > 0 || extra.moz.comprehensionExpressionStartsWithAssignment) {
-                  result2 = join7(result2, fragment);
+                  result2 = join8(result2, fragment);
                 } else {
                   result2.push(fragment);
                 }
@@ -30761,13 +30761,13 @@ var require_escodegen = __commonJS({
             });
           }
           if (expr.filter) {
-            result2 = join7(result2, "if" + space);
+            result2 = join8(result2, "if" + space);
             fragment = this.generateExpression(expr.filter, Precedence.Sequence, E_TTT);
-            result2 = join7(result2, ["(", fragment, ")"]);
+            result2 = join8(result2, ["(", fragment, ")"]);
           }
           if (!extra.moz.comprehensionExpressionStartsWithAssignment) {
             fragment = this.generateExpression(expr.body, Precedence.Assignment, E_TTT);
-            result2 = join7(result2, fragment);
+            result2 = join8(result2, fragment);
           }
           result2.push(expr.type === Syntax.GeneratorExpression ? ")" : "]");
           return result2;
@@ -30783,8 +30783,8 @@ var require_escodegen = __commonJS({
           } else {
             fragment = this.generateExpression(expr.left, Precedence.Call, E_TTT);
           }
-          fragment = join7(fragment, expr.of ? "of" : "in");
-          fragment = join7(fragment, this.generateExpression(expr.right, Precedence.Sequence, E_TTT));
+          fragment = join8(fragment, expr.of ? "of" : "in");
+          fragment = join8(fragment, this.generateExpression(expr.right, Precedence.Sequence, E_TTT));
           return ["for" + space + "(", fragment, ")"];
         },
         SpreadElement: function(expr, precedence, flags) {
@@ -33294,11 +33294,11 @@ var init_Validator = __esm({
     init_ValidationExecutor();
     __awaiter = function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve8) {
-          resolve8(value);
+        return value instanceof P ? value : new P(function(resolve9) {
+          resolve9(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve8, reject) {
+      return new (P || (P = Promise))(function(resolve9, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -33314,7 +33314,7 @@ var init_Validator = __esm({
           }
         }
         function step(result2) {
-          result2.done ? resolve8(result2.value) : adopt(result2.value).then(fulfilled, rejected);
+          result2.done ? resolve9(result2.value) : adopt(result2.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -57437,13 +57437,13 @@ function readdirp(root, options = {}) {
   options.root = root;
   return new ReaddirpStream(options);
 }
-var import_promises, import_node_stream, import_node_path5, EntryTypes, defaultOptions3, RECURSIVE_ERROR_CODE, NORMAL_FLOW_ERRORS, ALL_TYPES, DIR_TYPES, FILE_TYPES, isNormalFlowError, wantBigintFsStats, emptyFn, normalizeFilter, ReaddirpStream;
+var import_promises, import_node_stream, import_node_path6, EntryTypes, defaultOptions3, RECURSIVE_ERROR_CODE, NORMAL_FLOW_ERRORS, ALL_TYPES, DIR_TYPES, FILE_TYPES, isNormalFlowError, wantBigintFsStats, emptyFn, normalizeFilter, ReaddirpStream;
 var init_esm = __esm({
   "node_modules/readdirp/esm/index.js"() {
     "use strict";
     import_promises = require("fs/promises");
     import_node_stream = require("stream");
-    import_node_path5 = require("path");
+    import_node_path6 = require("path");
     EntryTypes = {
       FILE_TYPE: "files",
       DIR_TYPE: "directories",
@@ -57518,7 +57518,7 @@ var init_esm = __esm({
         this._wantsDir = type ? DIR_TYPES.has(type) : false;
         this._wantsFile = type ? FILE_TYPES.has(type) : false;
         this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
-        this._root = (0, import_node_path5.resolve)(root);
+        this._root = (0, import_node_path6.resolve)(root);
         this._isDirent = !opts.alwaysStat;
         this._statsProp = this._isDirent ? "dirent" : "stats";
         this._rdOptions = { encoding: "utf8", withFileTypes: this._isDirent };
@@ -57587,10 +57587,10 @@ var init_esm = __esm({
       }
       async _formatEntry(dirent, path) {
         let entry;
-        const basename7 = this._isDirent ? dirent.name : dirent;
+        const basename8 = this._isDirent ? dirent.name : dirent;
         try {
-          const fullPath = (0, import_node_path5.resolve)((0, import_node_path5.join)(path, basename7));
-          entry = { path: (0, import_node_path5.relative)(this._root, fullPath), fullPath, basename: basename7 };
+          const fullPath = (0, import_node_path6.resolve)((0, import_node_path6.join)(path, basename8));
+          entry = { path: (0, import_node_path6.relative)(this._root, fullPath), fullPath, basename: basename8 };
           entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
         } catch (err) {
           this._onError(err);
@@ -57624,7 +57624,7 @@ var init_esm = __esm({
             }
             if (entryRealPathStats.isDirectory()) {
               const len = entryRealPath.length;
-              if (full.startsWith(entryRealPath) && full.substr(len, 1) === import_node_path5.sep) {
+              if (full.startsWith(entryRealPath) && full.substr(len, 1) === import_node_path6.sep) {
                 const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
                 recursiveError.code = RECURSIVE_ERROR_CODE;
                 return this._onError(recursiveError);
@@ -57655,7 +57655,7 @@ function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
     }
   };
   try {
-    return (0, import_fs6.watch)(path, {
+    return (0, import_fs7.watch)(path, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -57663,11 +57663,11 @@ function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
     return void 0;
   }
 }
-var import_fs6, import_promises2, sysPath, import_os, STR_DATA, STR_END, STR_CLOSE, EMPTY_FN, pl, isWindows2, isMacos, isLinux, isFreeBSD, isIBMi, EVENTS, EV, THROTTLE_MODE_WATCH, statMethods, KEY_LISTENERS, KEY_ERR, KEY_RAW, HANDLER_KEYS, binaryExtensions, isBinaryPath, foreach, addAndConvert, clearItem, delFromSet, isEmptySet, FsWatchInstances, fsWatchBroadcast, setFsWatchListener, FsWatchFileInstances, setFsWatchFileListener, NodeFsHandler;
+var import_fs7, import_promises2, sysPath, import_os, STR_DATA, STR_END, STR_CLOSE, EMPTY_FN, pl, isWindows2, isMacos, isLinux, isFreeBSD, isIBMi, EVENTS, EV, THROTTLE_MODE_WATCH, statMethods, KEY_LISTENERS, KEY_ERR, KEY_RAW, HANDLER_KEYS, binaryExtensions, isBinaryPath, foreach, addAndConvert, clearItem, delFromSet, isEmptySet, FsWatchInstances, fsWatchBroadcast, setFsWatchListener, FsWatchFileInstances, setFsWatchFileListener, NodeFsHandler;
 var init_handler = __esm({
   "node_modules/chokidar/esm/handler.js"() {
     "use strict";
-    import_fs6 = require("fs");
+    import_fs7 = require("fs");
     import_promises2 = require("fs/promises");
     sysPath = __toESM(require("path"), 1);
     import_os = require("os");
@@ -58071,7 +58071,7 @@ var init_handler = __esm({
       let cont = FsWatchFileInstances.get(fullPath);
       const copts = cont && cont.options;
       if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
-        (0, import_fs6.unwatchFile)(fullPath);
+        (0, import_fs7.unwatchFile)(fullPath);
         cont = void 0;
       }
       if (cont) {
@@ -58082,7 +58082,7 @@ var init_handler = __esm({
           listeners: listener,
           rawEmitters: rawEmitter,
           options,
-          watcher: (0, import_fs6.watchFile)(fullPath, options, (curr, prev) => {
+          watcher: (0, import_fs7.watchFile)(fullPath, options, (curr, prev) => {
             foreach(cont.rawEmitters, (rawEmitter2) => {
               rawEmitter2(EV.CHANGE, fullPath, { curr, prev });
             });
@@ -58099,7 +58099,7 @@ var init_handler = __esm({
         delFromSet(cont, KEY_RAW, rawEmitter);
         if (isEmptySet(cont.listeners)) {
           FsWatchFileInstances.delete(fullPath);
-          (0, import_fs6.unwatchFile)(fullPath);
+          (0, import_fs7.unwatchFile)(fullPath);
           cont.options = cont.watcher = void 0;
           Object.freeze(cont);
         }
@@ -58119,9 +58119,9 @@ var init_handler = __esm({
       _watchWithNodeFs(path, listener) {
         const opts = this.fsw.options;
         const directory = sysPath.dirname(path);
-        const basename7 = sysPath.basename(path);
+        const basename8 = sysPath.basename(path);
         const parent = this.fsw._getWatchedDir(directory);
-        parent.add(basename7);
+        parent.add(basename8);
         const absolutePath = sysPath.resolve(path);
         const options = {
           persistent: opts.persistent
@@ -58131,7 +58131,7 @@ var init_handler = __esm({
         let closer;
         if (opts.usePolling) {
           const enableBin = opts.interval !== opts.binaryInterval;
-          options.interval = enableBin && isBinaryPath(basename7) ? opts.binaryInterval : opts.interval;
+          options.interval = enableBin && isBinaryPath(basename8) ? opts.binaryInterval : opts.interval;
           closer = setFsWatchFileListener(path, absolutePath, options, {
             listener,
             rawEmitter: this.fsw._emitRaw
@@ -58153,11 +58153,11 @@ var init_handler = __esm({
         if (this.fsw.closed) {
           return;
         }
-        const dirname8 = sysPath.dirname(file);
-        const basename7 = sysPath.basename(file);
-        const parent = this.fsw._getWatchedDir(dirname8);
+        const dirname9 = sysPath.dirname(file);
+        const basename8 = sysPath.basename(file);
+        const parent = this.fsw._getWatchedDir(dirname9);
         let prevStats = stats;
-        if (parent.has(basename7))
+        if (parent.has(basename8))
           return;
         const listener = async (path, newStats) => {
           if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
@@ -58182,9 +58182,9 @@ var init_handler = __esm({
                 prevStats = newStats2;
               }
             } catch (error) {
-              this.fsw._remove(dirname8, basename7);
+              this.fsw._remove(dirname9, basename8);
             }
-          } else if (parent.has(basename7)) {
+          } else if (parent.has(basename8)) {
             const at = newStats.atimeMs;
             const mt = newStats.mtimeMs;
             if (!at || at <= mt || mt !== prevStats.mtimeMs) {
@@ -58278,7 +58278,7 @@ var init_handler = __esm({
             this._addToNodeFs(path, initialAdd, wh, depth + 1);
           }
         }).on(EV.ERROR, this._boundHandleError);
-        return new Promise((resolve8, reject) => {
+        return new Promise((resolve9, reject) => {
           if (!stream)
             return reject();
           stream.once(STR_END, () => {
@@ -58287,7 +58287,7 @@ var init_handler = __esm({
               return;
             }
             const wasThrottled = throttler ? throttler.clear() : false;
-            resolve8(void 0);
+            resolve9(void 0);
             previous.getChildren().filter((item) => {
               return item !== directory && !current.has(item);
             }).forEach((item) => {
@@ -58484,11 +58484,11 @@ function watch3(paths, options = {}) {
   watcher.add(paths);
   return watcher;
 }
-var import_fs7, import_promises3, import_events4, sysPath2, SLASH, SLASH_SLASH, ONE_DOT, TWO_DOTS, STRING_TYPE, BACK_SLASH_RE, DOUBLE_SLASH_RE, DOT_RE, REPLACER_RE, isMatcherObject, unifyPaths, toUnix, normalizePathToUnix, normalizeIgnored, getAbsolutePath, EMPTY_SET, DirEntry, STAT_METHOD_F, STAT_METHOD_L, WatchHelper, FSWatcher2, esm_default;
+var import_fs8, import_promises3, import_events4, sysPath2, SLASH, SLASH_SLASH, ONE_DOT, TWO_DOTS, STRING_TYPE, BACK_SLASH_RE, DOUBLE_SLASH_RE, DOT_RE, REPLACER_RE, isMatcherObject, unifyPaths, toUnix, normalizePathToUnix, normalizeIgnored, getAbsolutePath, EMPTY_SET, DirEntry, STAT_METHOD_F, STAT_METHOD_L, WatchHelper, FSWatcher2, esm_default;
 var init_esm2 = __esm({
   "node_modules/chokidar/esm/index.js"() {
     "use strict";
-    import_fs7 = require("fs");
+    import_fs8 = require("fs");
     import_promises3 = require("fs/promises");
     import_events4 = require("events");
     sysPath2 = __toESM(require("path"), 1);
@@ -58966,7 +58966,7 @@ var init_esm2 = __esm({
         const now = /* @__PURE__ */ new Date();
         const writes = this._pendingWrites;
         function awaitWriteFinishFn(prevStat) {
-          (0, import_fs7.stat)(fullPath, (err, curStat) => {
+          (0, import_fs8.stat)(fullPath, (err, curStat) => {
             if (err || !writes.has(path)) {
               if (err && err.code !== "ENOENT")
                 awfEmit(err);
@@ -59400,7 +59400,7 @@ var require_package3 = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "elit",
-      version: "3.5.3",
+      version: "3.5.4",
       description: "Optimized lightweight library for creating DOM elements with reactive state",
       main: "dist/index.js",
       module: "dist/index.mjs",
@@ -59558,6 +59558,7 @@ var require_package3 = __commonJS({
         "test:run": "elit test --run",
         "test:coverage": "elit test --coverage",
         "test:e2e": "elit test --e2e",
+        "test:wapk:google-drive": "elit test --run --file ./testing/unit/wapk.google-drive.integration.test.ts",
         benchmark: "node benchmark/server-benchmark.js",
         "benchmark:router": "node benchmark/router-benchmark.js",
         "docs:dev": "npm run --prefix docs dev",
@@ -59639,6 +59640,7 @@ __export(cli_exports, {
   runDev: () => runDev,
   runMobile: () => runMobile,
   runNative: () => runNative,
+  runPm: () => runPm,
   runPreview: () => runPreview,
   runTest: () => runTest,
   runWapk: () => runWapk
@@ -59731,9 +59733,9 @@ async function loadConfigFile(configPath) {
   } else if (ext === "ts" || ext === "mts") {
     try {
       const { build: build2 } = await import("esbuild");
-      const { join: join7, dirname: dirname8 } = await Promise.resolve().then(() => (init_path(), path_exports));
-      const configDir = dirname8(configPath);
-      const tempFile = join7(configDir, `.elit-config-${Date.now()}.mjs`);
+      const { join: join8, dirname: dirname9 } = await Promise.resolve().then(() => (init_path(), path_exports));
+      const configDir = dirname9(configPath);
+      const tempFile = join8(configDir, `.elit-config-${Date.now()}.mjs`);
       const externalAllPlugin = {
         name: "external-all",
         setup(build3) {
@@ -60297,6 +60299,8 @@ var WebSocketServer = class extends import_events2.EventEmitter {
 
 // src/chokidar.ts
 var import_events3 = require("events");
+init_fs();
+init_path();
 init_runtime();
 function normalizePath2(path) {
   return path.replace(/\\/g, "/");
@@ -60418,18 +60422,35 @@ var FSWatcher = class extends import_events3.EventEmitter {
   }
 };
 function getBaseDirectory(pattern) {
-  const parts = pattern.split(/[\\\/]/);
+  const normalizedPattern = normalizePath2(pattern);
+  const parts = normalizedPattern.split(/[\\\/]/);
   let baseDir = "";
+  let sawGlob = false;
   for (const part of parts) {
     if (part.includes("*") || part.includes("?")) {
+      sawGlob = true;
       break;
     }
     baseDir = baseDir ? `${baseDir}/${part}` : part;
   }
-  return baseDir || ".";
+  if (sawGlob) {
+    return baseDir || ".";
+  }
+  if (normalizedPattern && existsSync(normalizedPattern)) {
+    try {
+      return statSync(normalizedPattern).isDirectory() ? normalizedPattern : normalizePath2(dirname(normalizedPattern)) || ".";
+    } catch {
+      return normalizePath2(dirname(normalizedPattern)) || ".";
+    }
+  }
+  const lastSegment = parts[parts.length - 1] || "";
+  if (lastSegment.includes(".") && !lastSegment.startsWith(".")) {
+    return normalizePath2(dirname(normalizedPattern)) || ".";
+  }
+  return normalizedPattern || ".";
 }
 function matchesPattern(filePath, pattern) {
-  const regexPattern = normalizePath2(pattern).replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/\?/g, ".");
+  const regexPattern = normalizePath2(pattern).replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/\?/g, ".");
   const regex = new RegExp(`^${regexPattern}$`);
   const normalizedPath = normalizePath2(filePath);
   return regex.test(normalizedPath);
@@ -62505,10 +62526,10 @@ ${elitImportMap}`;
       webSocketServers.forEach((wsServer) => wsServer.close());
       wsClients.clear();
     }
-    return new Promise((resolve8) => {
+    return new Promise((resolve9) => {
       server.close(() => {
         if (config.logging) console.log("[Server] Closed");
-        resolve8();
+        resolve9();
       });
     });
   };
@@ -74451,6 +74472,7 @@ var WAPK_SALT_LENGTH = 16;
 var WAPK_IV_LENGTH = 12;
 var WAPK_AUTH_TAG_LENGTH = 16;
 var WAPK_SCRYPT_OPTIONS = { N: 16384, r: 8, p: 1 };
+var DEFAULT_GOOGLE_DRIVE_TOKEN_ENV = "GOOGLE_DRIVE_ACCESS_TOKEN";
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -74526,6 +74548,47 @@ function normalizeWapkConfig(value) {
     lock: normalizeWapkLockConfig(value.lock)
   };
 }
+function normalizeWapkGoogleDriveConfig(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const normalized = {
+    fileId: normalizeNonEmptyString(value.fileId),
+    accessToken: normalizeNonEmptyString(value.accessToken),
+    accessTokenEnv: normalizeNonEmptyString(value.accessTokenEnv),
+    supportsAllDrives: normalizeBoolean(value.supportsAllDrives)
+  };
+  return Object.values(normalized).some((entry) => entry !== void 0) ? normalized : void 0;
+}
+function normalizeBoolean(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function normalizeSyncInterval(value) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  const interval = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(interval) || interval < 50) {
+    return void 0;
+  }
+  return Math.trunc(interval);
+}
+function normalizeWapkRunConfig(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const normalized = {
+    file: normalizeNonEmptyString(value.file),
+    googleDrive: normalizeWapkGoogleDriveConfig(value.googleDrive),
+    runtime: normalizeRuntime(value.runtime),
+    syncInterval: normalizeSyncInterval(value.syncInterval),
+    useWatcher: normalizeBoolean(value.useWatcher),
+    watchArchive: normalizeBoolean(value.watchArchive),
+    archiveSyncInterval: normalizeSyncInterval(value.archiveSyncInterval),
+    password: normalizeNonEmptyString(value.password)
+  };
+  return Object.values(normalized).some((entry) => entry !== void 0) ? normalized : void 0;
+}
 function sanitizePackageName(name) {
   const sanitized = name.trim().replace(/[<>:"/\\|?*\x00-\x1F]+/g, "-").replace(/\s+/g, "-").replace(/-+/g, "-");
   return sanitized.length > 0 ? sanitized : "app";
@@ -74972,49 +75035,360 @@ function extractFiles(files, destination) {
   }
 }
 function collectRuntimeSyncFiles(directory) {
-  const files = collectFiles(directory, directory, []);
-  return files.filter((file) => {
+  return filterRuntimeSyncFiles(collectFiles(directory, directory, []));
+}
+function filterRuntimeSyncFiles(files) {
+  return [...files].filter((file) => {
     const firstPart = file.path.split("/")[0] ?? "";
     return !RUNTIME_SYNC_IGNORE.has(firstPart);
   }).sort((left, right) => left.path.localeCompare(right.path));
 }
-function writeWapkArchiveFromMemory(archivePath, header, files, lock) {
+function getLocalArchiveSignature(archivePath) {
+  try {
+    const stats = (0, import_node_fs2.statSync)(archivePath);
+    return `${stats.size}:${stats.mtimeMs}`;
+  } catch {
+    return void 0;
+  }
+}
+function createGoogleDriveArchiveSignature(metadata) {
+  const signature = [metadata.modifiedTime, metadata.size, metadata.md5Checksum].filter((value) => typeof value === "string" && value.length > 0).join(":");
+  return signature.length > 0 ? signature : void 0;
+}
+async function readResponseMessage(response) {
+  try {
+    const text = (await response.text()).trim();
+    return text.length > 0 ? text.slice(0, 400) : response.statusText;
+  } catch {
+    return response.statusText;
+  }
+}
+function buildGoogleDriveFileUrl(fileId, params) {
+  const url = new URL(`https://www.googleapis.com/drive/v3/files/${encodeURIComponent(fileId)}`);
+  for (const [key, value] of Object.entries(params)) {
+    if (value === void 0) {
+      continue;
+    }
+    url.searchParams.set(key, typeof value === "boolean" ? String(value) : value);
+  }
+  return url.toString();
+}
+function buildGoogleDriveUploadUrl(fileId, params) {
+  const url = new URL(`https://www.googleapis.com/upload/drive/v3/files/${encodeURIComponent(fileId)}`);
+  for (const [key, value] of Object.entries(params)) {
+    if (value === void 0) {
+      continue;
+    }
+    url.searchParams.set(key, typeof value === "boolean" ? String(value) : value);
+  }
+  return url.toString();
+}
+async function fetchGoogleDriveMetadata(config) {
+  const response = await fetch(buildGoogleDriveFileUrl(config.fileId, {
+    fields: "id,name,modifiedTime,size,md5Checksum",
+    supportsAllDrives: config.supportsAllDrives
+  }), {
+    headers: {
+      Authorization: `Bearer ${config.accessToken}`
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`Google Drive metadata request failed (${response.status}): ${await readResponseMessage(response)}`);
+  }
+  const payload = await response.json();
+  return {
+    name: normalizeNonEmptyString(payload?.name),
+    modifiedTime: normalizeNonEmptyString(payload?.modifiedTime),
+    size: normalizeNonEmptyString(payload?.size),
+    md5Checksum: normalizeNonEmptyString(payload?.md5Checksum)
+  };
+}
+async function downloadGoogleDriveArchive(config) {
+  const metadata = await fetchGoogleDriveMetadata(config);
+  const response = await fetch(buildGoogleDriveFileUrl(config.fileId, {
+    alt: "media",
+    supportsAllDrives: config.supportsAllDrives
+  }), {
+    headers: {
+      Authorization: `Bearer ${config.accessToken}`
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`Google Drive download failed (${response.status}): ${await readResponseMessage(response)}`);
+  }
+  const arrayBuffer = await response.arrayBuffer();
+  return {
+    buffer: Buffer.from(arrayBuffer),
+    signature: createGoogleDriveArchiveSignature(metadata),
+    label: metadata.name ?? `Google Drive:${config.fileId}`
+  };
+}
+async function uploadGoogleDriveArchive(config, buffer) {
+  const response = await fetch(buildGoogleDriveUploadUrl(config.fileId, {
+    uploadType: "media",
+    fields: "id,name,modifiedTime,size,md5Checksum",
+    supportsAllDrives: config.supportsAllDrives
+  }), {
+    method: "PATCH",
+    headers: {
+      Authorization: `Bearer ${config.accessToken}`,
+      "Content-Type": "application/octet-stream"
+    },
+    body: new Uint8Array(buffer)
+  });
+  if (!response.ok) {
+    throw new Error(`Google Drive upload failed (${response.status}): ${await readResponseMessage(response)}`);
+  }
+  const payload = await response.json();
+  const metadata = {
+    name: normalizeNonEmptyString(payload?.name),
+    modifiedTime: normalizeNonEmptyString(payload?.modifiedTime),
+    size: normalizeNonEmptyString(payload?.size),
+    md5Checksum: normalizeNonEmptyString(payload?.md5Checksum)
+  };
+  return {
+    buffer,
+    signature: createGoogleDriveArchiveSignature(metadata),
+    label: metadata.name ?? `Google Drive:${config.fileId}`
+  };
+}
+function resolveGoogleDriveAccessToken(config) {
+  const explicitToken = normalizeNonEmptyString(config?.accessToken);
+  const configuredEnvName = normalizeNonEmptyString(config?.accessTokenEnv);
+  const configuredEnvToken = configuredEnvName ? normalizeNonEmptyString(process.env[configuredEnvName]) : void 0;
+  const defaultEnvToken = normalizeNonEmptyString(process.env[DEFAULT_GOOGLE_DRIVE_TOKEN_ENV]);
+  const token = explicitToken ?? configuredEnvToken ?? defaultEnvToken;
+  if (token) {
+    return token;
+  }
+  if (configuredEnvName) {
+    throw new Error(`Google Drive access token not found in environment variable ${configuredEnvName}.`);
+  }
+  throw new Error(`Google Drive access token is required. Provide googleDrive.accessToken, googleDrive.accessTokenEnv, or set ${DEFAULT_GOOGLE_DRIVE_TOKEN_ENV}.`);
+}
+function parseGoogleDriveArchiveSpecifier(value) {
+  const match = value.match(/^(?:gdrive|google-drive):\/\/(.+)$/i);
+  if (!match) {
+    return void 0;
+  }
+  const fileId = match[1]?.trim();
+  return fileId && fileId.length > 0 ? fileId : void 0;
+}
+function resolveGoogleDriveConfig(archiveSpecifier, googleDrive) {
+  const fileId = normalizeNonEmptyString(googleDrive?.fileId) ?? parseGoogleDriveArchiveSpecifier(archiveSpecifier);
+  if (!fileId) {
+    return void 0;
+  }
+  return {
+    fileId,
+    accessToken: resolveGoogleDriveAccessToken(googleDrive),
+    accessTokenEnv: normalizeNonEmptyString(googleDrive?.accessTokenEnv),
+    supportsAllDrives: googleDrive?.supportsAllDrives ?? false
+  };
+}
+function createLocalArchiveHandle(archivePath) {
+  const resolvedArchivePath = (0, import_node_path2.resolve)(archivePath);
+  const readLocalBuffer = () => {
+    if (!(0, import_node_fs2.existsSync)(resolvedArchivePath)) {
+      throw new Error(`WAPK file not found: ${resolvedArchivePath}`);
+    }
+    return (0, import_node_fs2.readFileSync)(resolvedArchivePath);
+  };
+  return {
+    identifier: resolvedArchivePath,
+    label: (0, import_node_path2.basename)(resolvedArchivePath),
+    readSnapshot: async () => ({
+      buffer: readLocalBuffer(),
+      signature: getLocalArchiveSignature(resolvedArchivePath),
+      label: (0, import_node_path2.basename)(resolvedArchivePath)
+    }),
+    getSignature: async () => getLocalArchiveSignature(resolvedArchivePath),
+    writeBuffer: async (buffer) => {
+      (0, import_node_fs2.writeFileSync)(resolvedArchivePath, buffer);
+      return {
+        buffer,
+        signature: getLocalArchiveSignature(resolvedArchivePath),
+        label: (0, import_node_path2.basename)(resolvedArchivePath)
+      };
+    }
+  };
+}
+function createGoogleDriveArchiveHandle(config) {
+  const identifier = `gdrive://${config.fileId}`;
+  const label = `Google Drive:${config.fileId}`;
+  return {
+    identifier,
+    label,
+    readSnapshot: async () => downloadGoogleDriveArchive(config),
+    getSignature: async () => createGoogleDriveArchiveSignature(await fetchGoogleDriveMetadata(config)),
+    writeBuffer: async (buffer) => uploadGoogleDriveArchive(config, buffer)
+  };
+}
+function resolveArchiveHandle(archiveSpecifier, googleDrive) {
+  const googleDriveConfig = resolveGoogleDriveConfig(archiveSpecifier, googleDrive);
+  if (googleDriveConfig) {
+    return createGoogleDriveArchiveHandle(googleDriveConfig);
+  }
+  return createLocalArchiveHandle(archiveSpecifier);
+}
+async function writeWapkArchiveFromMemory(archiveHandle, header, files, lock) {
   const updatedHeader = {
     ...header,
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  (0, import_node_fs2.writeFileSync)(archivePath, encodeWapk(updatedHeader, files, lock));
+  const snapshot = await archiveHandle.writeBuffer(encodeWapk(updatedHeader, files, lock));
+  return {
+    header: updatedHeader,
+    signature: snapshot.signature,
+    label: snapshot.label ?? archiveHandle.label
+  };
+}
+function removeEmptyParentDirectories(directory, rootDir) {
+  let currentDir = directory;
+  while (true) {
+    const relativeDir = (0, import_node_path2.relative)(rootDir, currentDir);
+    if (!relativeDir || relativeDir.startsWith("..") || (0, import_node_path2.isAbsolute)(relativeDir)) {
+      return;
+    }
+    try {
+      if ((0, import_node_fs2.readdirSync)(currentDir).length > 0) {
+        return;
+      }
+      (0, import_node_fs2.rmSync)(currentDir, { recursive: false, force: true });
+    } catch {
+      return;
+    }
+    currentDir = (0, import_node_path2.dirname)(currentDir);
+  }
+}
+function applyArchiveFilesToWorkDir(directory, files) {
+  const existingFiles = collectRuntimeSyncFiles(directory);
+  const nextPaths = new Set(files.map((file) => file.path));
+  for (const file of existingFiles) {
+    if (nextPaths.has(file.path)) {
+      continue;
+    }
+    const filePath = (0, import_node_path2.join)(directory, ...file.path.split("/"));
+    (0, import_node_fs2.rmSync)(filePath, { force: true });
+    removeEmptyParentDirectories((0, import_node_path2.dirname)(filePath), directory);
+  }
+  extractFiles(files, directory);
+}
+async function readArchiveRuntimeState(archiveHandle, lock) {
+  const snapshot = await archiveHandle.readSnapshot();
+  const decoded = decodeWapk(snapshot.buffer, lock ? { password: lock.password } : {});
+  return {
+    header: decoded.header,
+    files: filterRuntimeSyncFiles(decoded.files),
+    signature: snapshot.signature,
+    label: snapshot.label ?? archiveHandle.label
+  };
 }
 function createWapkLiveSync(prepared) {
   let memoryFiles = collectRuntimeSyncFiles(prepared.workDir);
   const syncInterval = prepared.syncInterval ?? 300;
+  const archiveSyncInterval = prepared.archiveSyncInterval ?? syncInterval;
+  const watchArchive = prepared.watchArchive ?? true;
+  let currentHeader = prepared.header;
+  let currentArchiveLabel = prepared.archiveLabel;
   let stopped = false;
-  const flush = () => {
-    if (stopped) return;
-    const nextFiles = collectRuntimeSyncFiles(prepared.workDir);
-    if (filesEqual(memoryFiles, nextFiles)) {
-      return;
+  let lastArchiveSignature = prepared.archiveSignature;
+  let lastArchivePollAt = 0;
+  let pendingOperation = Promise.resolve();
+  const reportSyncError = (error) => {
+    console.warn(
+      `[wapk] Sync error for ${currentArchiveLabel}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  };
+  const pullArchiveChanges = async () => {
+    if (!watchArchive) {
+      return false;
+    }
+    const archiveSignature = await prepared.archiveHandle.getSignature();
+    if (!archiveSignature || archiveSignature === lastArchiveSignature) {
+      return false;
+    }
+    try {
+      const archiveState = await readArchiveRuntimeState(prepared.archiveHandle, prepared.lock);
+      lastArchiveSignature = archiveState.signature ?? archiveSignature;
+      currentHeader = archiveState.header;
+      currentArchiveLabel = archiveState.label;
+      if (filesEqual(memoryFiles, archiveState.files)) {
+        return false;
+      }
+      applyArchiveFilesToWorkDir(prepared.workDir, archiveState.files);
+      memoryFiles = archiveState.files;
+      return true;
+    } catch (error) {
+      console.warn(
+        `[wapk] Failed to pull external archive changes from ${currentArchiveLabel}: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return false;
     }
-    memoryFiles = nextFiles;
-    writeWapkArchiveFromMemory(prepared.archivePath, prepared.header, memoryFiles, prepared.lock);
+  };
+  const flush = () => {
+    pendingOperation = pendingOperation.catch(() => void 0).then(async () => {
+      if (stopped) return;
+      const nextFiles = collectRuntimeSyncFiles(prepared.workDir);
+      const localDirty = !filesEqual(memoryFiles, nextFiles);
+      const now = Date.now();
+      const shouldPollArchive = watchArchive && (lastArchivePollAt === 0 || now - lastArchivePollAt >= archiveSyncInterval);
+      if (!localDirty && shouldPollArchive) {
+        lastArchivePollAt = now;
+        await pullArchiveChanges();
+        return;
+      }
+      if (!localDirty) {
+        return;
+      }
+      if (shouldPollArchive) {
+        lastArchivePollAt = now;
+        const archiveSignature = await prepared.archiveHandle.getSignature();
+        if (archiveSignature && archiveSignature !== lastArchiveSignature) {
+          console.warn(
+            `[wapk] Both the workdir and ${currentArchiveLabel} changed; writing local workdir changes back to the archive.`
+          );
+        }
+      }
+      memoryFiles = nextFiles;
+      const writeResult = await writeWapkArchiveFromMemory(prepared.archiveHandle, currentHeader, memoryFiles, prepared.lock);
+      currentHeader = writeResult.header;
+      currentArchiveLabel = writeResult.label;
+      lastArchiveSignature = writeResult.signature ?? await prepared.archiveHandle.getSignature();
+    });
+    return pendingOperation;
+  };
+  const scheduleFlush = () => {
+    void flush().catch(reportSyncError);
   };
   if (prepared.useWatcher) {
     const watcher = (0, import_node_fs2.watch)(prepared.workDir, { recursive: true }, () => {
-      flush();
+      scheduleFlush();
     });
-    const stop2 = () => {
-      flush();
-      stopped = true;
+    const archiveTimer = watchArchive ? setInterval(() => {
+      scheduleFlush();
+    }, archiveSyncInterval) : void 0;
+    archiveTimer?.unref?.();
+    const stop2 = async () => {
+      if (stopped) return pendingOperation;
       watcher.close();
+      if (archiveTimer) {
+        clearInterval(archiveTimer);
+      }
+      await flush();
+      stopped = true;
+      await pendingOperation;
     };
     return { flush, stop: stop2 };
   }
-  const timer = setInterval(flush, syncInterval);
+  const timer = setInterval(scheduleFlush, watchArchive ? Math.min(syncInterval, archiveSyncInterval) : syncInterval);
   timer.unref?.();
-  const stop = () => {
-    flush();
-    stopped = true;
+  const stop = async () => {
+    if (stopped) return;
     clearInterval(timer);
+    await flush();
+    stopped = true;
+    await pendingOperation;
   };
   return { flush, stop };
 }
@@ -75155,12 +75529,11 @@ function extractWapkArchive(wapkPath, outputDir = ".", options = {}) {
   console.log(`Extracted ${archive.files.length} files to: ${extractDirectory}`);
   return extractDirectory;
 }
-function prepareWapkApp(wapkPath, options = {}) {
-  const archivePath = (0, import_node_path2.resolve)(wapkPath);
-  if (!(0, import_node_fs2.existsSync)(archivePath)) {
-    throw new Error(`WAPK file not found: ${archivePath}`);
-  }
-  const buffer = (0, import_node_fs2.readFileSync)(archivePath);
+async function prepareWapkApp(wapkPath, options = {}) {
+  const archiveHandle = resolveArchiveHandle(wapkPath, options.googleDrive);
+  const archivePath = archiveHandle.identifier;
+  const snapshot = await archiveHandle.readSnapshot();
+  const buffer = snapshot.buffer;
   const envelope = parseWapkEnvelope(buffer);
   const lock = envelope.version === WAPK_LOCKED_VERSION ? resolveArchiveCredentials(options) : void 0;
   const decoded = decodeWapk(buffer, options);
@@ -75175,12 +75548,17 @@ function prepareWapkApp(wapkPath, options = {}) {
   }
   return {
     archivePath,
+    archiveLabel: snapshot.label ?? archiveHandle.label,
+    archiveHandle,
+    archiveSignature: snapshot.signature,
     workDir,
     entryPath,
     header: decoded.header,
     runtime: runtime2,
     syncInterval: options.syncInterval,
     useWatcher: options.useWatcher,
+    watchArchive: options.watchArchive,
+    archiveSyncInterval: options.archiveSyncInterval,
     lock
   };
 }
@@ -75219,7 +75597,7 @@ async function runPreparedWapkApp(prepared) {
   } finally {
     process.off("SIGINT", onSigInt);
     process.off("SIGTERM", onSigTerm);
-    sync.stop();
+    await sync.stop();
     (0, import_node_fs2.rmSync)(prepared.workDir, { recursive: true, force: true });
   }
 }
@@ -75263,11 +75641,13 @@ function printWapkHelp() {
     "WAPK packaging for Elit",
     "",
     "Usage:",
-    "  elit wapk <file.wapk>",
-    "  elit wapk run <file.wapk>",
-    "  elit wapk run <file.wapk> --runtime node|bun|deno",
-    "  elit wapk run <file.wapk> --sync-interval 100",
-    "  elit wapk run <file.wapk> --watcher",
+    "  elit wapk [file.wapk]",
+    "  elit wapk gdrive://<fileId>",
+    "  elit wapk run [file.wapk]",
+    "  elit wapk run --google-drive-file-id <fileId> --google-drive-token-env <env>",
+    "  elit wapk run [file.wapk] --runtime node|bun|deno",
+    "  elit wapk run [file.wapk] --sync-interval 100",
+    "  elit wapk run [file.wapk] --watcher",
     "  elit wapk pack [directory]",
     "  elit wapk pack [directory] --password secret-123",
     "  elit wapk pack [directory] --include-deps",
@@ -75277,14 +75657,23 @@ function printWapkHelp() {
     "Options:",
     "  -r, --runtime <name>         Runtime override: node, bun, deno",
     "  --sync-interval <ms>         Polling interval for live sync (ms, default 300)",
+    "  --archive-sync-interval <ms> Polling interval for reading archive source changes",
     "  --watcher, --use-watcher     Use event-driven file watcher instead of polling",
+    "  --archive-watch              Pull external archive changes back into the temp workdir",
+    "  --no-archive-watch           Disable external archive read sync",
+    "  --google-drive-file-id <id>  Run a remote .wapk directly from Google Drive",
+    "  --google-drive-token-env <name>  Env var containing the Google Drive OAuth token",
+    "  --google-drive-access-token <value>  OAuth token for Google Drive API calls",
+    "  --google-drive-shared-drive  Include supportsAllDrives=true for shared drives",
     "  --include-deps               Include node_modules in the archive",
     "  --password <value>           Password for locking or unlocking the archive",
     "  -h, --help                   Show this help",
     "",
     "Notes:",
     "  - Pack reads wapk from elit.config.* and falls back to package.json.",
-    "  - Run mode keeps files in RAM and syncs changes back to the .wapk file.",
+    "  - Run mode can read config.wapk.run for default file/runtime/live-sync options.",
+    "  - Run mode keeps files in RAM and syncs changes both to and from the archive source.",
+    "  - Google Drive mode talks to the Drive API directly; no local archive file is required.",
     "  - Locked archives require the same password for run/extract/inspect.",
     "  - Archives stay unlocked by default unless a password is provided.",
     "  - Use --watcher for faster file change detection (less CPU usage).",
@@ -75325,9 +75714,12 @@ function parseArchiveAccessArgs(args, usage) {
 }
 function parseRunArgs(args) {
   let file;
+  let googleDrive;
   let runtime2;
   let syncInterval;
-  let useWatcher = false;
+  let useWatcher;
+  let watchArchive;
+  let archiveSyncInterval;
   let password;
   for (let index = 0; index < args.length; index++) {
     const arg = args[index];
@@ -75349,11 +75741,55 @@ function parseRunArgs(args) {
         syncInterval = value;
         break;
       }
+      case "--archive-sync-interval": {
+        const value = parseInt(readRequiredOptionValue(args, ++index, "--archive-sync-interval"), 10);
+        if (Number.isNaN(value) || value < 50) {
+          throw new Error("--archive-sync-interval must be a number >= 50 (milliseconds)");
+        }
+        archiveSyncInterval = value;
+        break;
+      }
       case "--use-watcher":
       case "--watcher": {
         useWatcher = true;
         break;
       }
+      case "--archive-watch": {
+        watchArchive = true;
+        break;
+      }
+      case "--no-archive-watch": {
+        watchArchive = false;
+        break;
+      }
+      case "--google-drive-file-id": {
+        googleDrive = {
+          ...googleDrive,
+          fileId: readRequiredOptionValue(args, ++index, "--google-drive-file-id")
+        };
+        break;
+      }
+      case "--google-drive-token-env": {
+        googleDrive = {
+          ...googleDrive,
+          accessTokenEnv: readRequiredOptionValue(args, ++index, "--google-drive-token-env")
+        };
+        break;
+      }
+      case "--google-drive-access-token": {
+        googleDrive = {
+          ...googleDrive,
+          accessToken: readRequiredOptionValue(args, ++index, "--google-drive-access-token")
+        };
+        break;
+      }
+      case "--google-drive-shared-drive": {
+        googleDrive = {
+          ...googleDrive,
+          supportsAllDrives: true
+        };
+        break;
+      }
       case "--password":
         password = readRequiredOptionValue(args, ++index, "--password");
         break;
@@ -75368,10 +75804,7 @@ function parseRunArgs(args) {
         break;
     }
   }
-  if (!file) {
-    throw new Error("Usage: elit wapk run <file.wapk>");
-  }
-  return { file, runtime: runtime2, syncInterval, useWatcher, password };
+  return { file, googleDrive, runtime: runtime2, syncInterval, useWatcher, watchArchive, archiveSyncInterval, password };
 }
 function parsePackArgs(args) {
   let directory = ".";
@@ -75397,8 +75830,63 @@ function parsePackArgs(args) {
   }
   return { directory, includeDeps, password };
 }
-async function runWapkCommand(args) {
-  if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
+async function readConfiguredWapkRunDefaults(cwd) {
+  const config = await loadConfig(cwd);
+  const runConfig = normalizeWapkRunConfig(config?.wapk?.run);
+  const fallbackPassword = normalizeNonEmptyString(config?.wapk?.lock?.password);
+  if (!runConfig) {
+    return fallbackPassword ? { password: fallbackPassword } : void 0;
+  }
+  if (!runConfig.password && fallbackPassword) {
+    runConfig.password = fallbackPassword;
+  }
+  if (runConfig.file && runConfig.googleDrive?.fileId) {
+    throw new Error("config.wapk.run.file and config.wapk.run.googleDrive.fileId are mutually exclusive.");
+  }
+  return runConfig;
+}
+function mergeGoogleDriveRunConfig(cliConfig, defaultConfig) {
+  if (!cliConfig && !defaultConfig) {
+    return void 0;
+  }
+  const merged = {
+    fileId: normalizeNonEmptyString(cliConfig?.fileId) ?? normalizeNonEmptyString(defaultConfig?.fileId),
+    accessToken: normalizeNonEmptyString(cliConfig?.accessToken) ?? normalizeNonEmptyString(defaultConfig?.accessToken),
+    accessTokenEnv: normalizeNonEmptyString(cliConfig?.accessTokenEnv) ?? normalizeNonEmptyString(defaultConfig?.accessTokenEnv),
+    supportsAllDrives: cliConfig?.supportsAllDrives ?? defaultConfig?.supportsAllDrives
+  };
+  return Object.values(merged).some((entry) => entry !== void 0) ? merged : void 0;
+}
+function resolveConfiguredWapkRunOptions(options, defaults) {
+  return {
+    file: options.file ?? defaults?.file,
+    googleDrive: mergeGoogleDriveRunConfig(options.googleDrive, defaults?.googleDrive),
+    runtime: options.runtime ?? defaults?.runtime,
+    syncInterval: options.syncInterval ?? defaults?.syncInterval,
+    useWatcher: options.useWatcher ?? defaults?.useWatcher,
+    watchArchive: options.watchArchive ?? defaults?.watchArchive,
+    archiveSyncInterval: options.archiveSyncInterval ?? defaults?.archiveSyncInterval,
+    password: options.password ?? defaults?.password
+  };
+}
+function resolveRunArchivePath(file, cwd) {
+  return (0, import_node_path2.isAbsolute)(file) ? file : (0, import_node_path2.resolve)(cwd, file);
+}
+function resolveRunArchiveSpecifier(file, googleDrive, cwd) {
+  const googleDriveFileId = normalizeNonEmptyString(googleDrive?.fileId);
+  if (googleDriveFileId) {
+    if (file && !parseGoogleDriveArchiveSpecifier(file)) {
+      throw new Error("WAPK run cannot use both a local archive file and googleDrive.fileId at the same time.");
+    }
+    return `gdrive://${googleDriveFileId}`;
+  }
+  if (!file) {
+    return void 0;
+  }
+  return parseGoogleDriveArchiveSpecifier(file) ? file : resolveRunArchivePath(file, cwd);
+}
+async function runWapkCommand(args, cwd = process.cwd()) {
+  if (args.includes("--help") || args.includes("-h")) {
     printWapkHelp();
     return;
   }
@@ -75420,11 +75908,24 @@ async function runWapkCommand(args) {
     extractWapkArchive(options.file, ".", options);
     return;
   }
-  const runOptions = args[0] === "run" ? parseRunArgs(args.slice(1)) : parseRunArgs(args);
-  const prepared = prepareWapkApp(runOptions.file, {
+  const parsedRunOptions = args[0] === "run" ? parseRunArgs(args.slice(1)) : parseRunArgs(args);
+  const configuredRunDefaults = await readConfiguredWapkRunDefaults(cwd);
+  const runOptions = resolveConfiguredWapkRunOptions(parsedRunOptions, configuredRunDefaults);
+  const archiveSpecifier = resolveRunArchiveSpecifier(runOptions.file, runOptions.googleDrive, cwd);
+  if (!archiveSpecifier) {
+    if (args.length === 0) {
+      printWapkHelp();
+      return;
+    }
+    throw new Error("Usage: elit wapk run <file.wapk>");
+  }
+  const prepared = await prepareWapkApp(archiveSpecifier, {
+    googleDrive: runOptions.googleDrive,
     runtime: runOptions.runtime,
     syncInterval: runOptions.syncInterval,
     useWatcher: runOptions.useWatcher,
+    watchArchive: runOptions.watchArchive,
+    archiveSyncInterval: runOptions.archiveSyncInterval,
     password: runOptions.password
   });
   const exitCode = await runPreparedWapkApp(prepared);
@@ -75851,7 +76352,7 @@ async function runDesktopWapkCommand(args, config) {
     return;
   }
   const options = parseDesktopWapkRunArgs(args, config?.wapk);
-  const preparedApp = prepareWapkApp(options.file, {
+  const preparedApp = await prepareWapkApp(options.file, {
     runtime: options.runtime,
     syncInterval: options.syncInterval,
     useWatcher: options.useWatcher,
@@ -75870,7 +76371,7 @@ async function runDesktopWapkCommand(args, config) {
       process.exit(exitCode);
     }
   } finally {
-    liveSync.stop();
+    await liveSync.stop();
     (0, import_node_fs3.rmSync)(preparedApp.workDir, { recursive: true, force: true });
     cleanupPreparedEntry(preparedEntry);
   }
@@ -76953,7 +77454,7 @@ function openMobileProject(platform, options) {
       throw new Error(`Android project not found at ${projectPath}. Run "elit mobile init" first.`);
     }
     if (process.platform === "win32") {
-      runCommand("cmd", ["/c", "start", "", projectPath], options.cwd);
+      runCommand("explorer.exe", [projectPath], options.cwd);
       return;
     }
     if (process.platform === "darwin") {
@@ -77159,10 +77660,11 @@ function commandExists(command, cwd) {
   });
   return result2.status === 0;
 }
-function resolveCommandPath(command, cwd) {
+function resolveCommandPath(command, cwd, env) {
   const checker = process.platform === "win32" ? "where" : "which";
   const result2 = (0, import_node_child_process3.spawnSync)(checker, [command], {
     cwd,
+    env,
     encoding: "utf8",
     shell: false
   });
@@ -77223,7 +77725,13 @@ function runGradle(cwd, args) {
       '[mobile] Gradle not found. Install Gradle and add it to PATH, or generate wrapper files in android/ with "gradle wrapper".'
     );
   }
-  runCommand(gradleCommand.command, args, androidRoot);
+  const env = gradleCommand.prependPath ? prependCommandPath(gradleCommand.prependPath) : void 0;
+  if (process.platform === "win32" && gradleCommand.useWindowsBatchShell) {
+    const shellCommand = gradleCommand.batchCommandPath ?? resolveCommandPath(gradleCommand.command, androidRoot, env) ?? gradleCommand.command;
+    runWindowsBatchCommand(shellCommand, args, androidRoot);
+    return;
+  }
+  runCommand(gradleCommand.command, args, androidRoot, env);
 }
 function resolveGradleCommand(cwd) {
   const androidRoot = (0, import_node_path4.join)(cwd, "android");
@@ -77232,22 +77740,31 @@ function resolveGradleCommand(cwd) {
   if ((0, import_node_fs4.existsSync)(wrapperPath)) {
     return {
       command: wrapper,
-      details: "Using project gradle wrapper."
+      batchCommandPath: wrapperPath,
+      details: "Using project gradle wrapper.",
+      useWindowsBatchShell: process.platform === "win32"
     };
   }
   if (commandExists("gradle", androidRoot)) {
     return {
       command: "gradle",
-      details: "Using Gradle from PATH."
+      batchCommandPath: process.platform === "win32" ? resolveCommandPath("gradle", androidRoot) ?? "gradle" : void 0,
+      details: "Using Gradle from PATH.",
+      useWindowsBatchShell: process.platform === "win32"
     };
   }
   const fallbackGradle = resolveFallbackGradleExecutable();
   if (!fallbackGradle) {
     return void 0;
   }
+  const prependPath = process.platform === "win32" ? (0, import_node_path4.dirname)(fallbackGradle) : void 0;
+  const fallbackEnv = prependPath ? prependCommandPath(prependPath) : void 0;
   return {
-    command: fallbackGradle,
-    details: `Using fallback Gradle at ${fallbackGradle}.`
+    command: process.platform === "win32" ? "gradle" : fallbackGradle,
+    batchCommandPath: process.platform === "win32" ? resolveCommandPath("gradle", androidRoot, fallbackEnv) ?? void 0 : void 0,
+    details: `Using fallback Gradle at ${fallbackGradle}.`,
+    prependPath,
+    useWindowsBatchShell: process.platform === "win32"
   };
 }
 function resolveFallbackGradleExecutable() {
@@ -77403,26 +77920,28 @@ function upsertXmlAttribute(tag, name, value) {
   }
   return `${tag.slice(0, -1)} ${name}='${value}'>`;
 }
-var WIN_CMD_META = /([()%!^"\`<>&|;, *?])/g;
-function escapeWindowsShellArg(value) {
-  const quoted = `"${value.replace(/(\\*)"/, '$1$1\\"').replace(/(\\*)$/, "$1$1")}"`;
-  return quoted.replace(WIN_CMD_META, "^$1");
-}
-function spawnWin32Safe(command, args, cwd, stdio) {
-  const safeCommand = (0, import_node_path4.normalize)(command).replace(WIN_CMD_META, "^$1");
-  const safeArgs = args.map(escapeWindowsShellArg);
-  const commandLine = `"${[safeCommand, ...safeArgs].join(" ")}"`;
-  const comSpec = process.env.ComSpec || "cmd.exe";
-  return (0, import_node_child_process3.spawnSync)(comSpec, ["/d", "/s", "/c", commandLine], {
+function prependCommandPath(pathEntry) {
+  const pathKey = Object.keys(process.env).find((key) => key.toLowerCase() === "path") ?? "PATH";
+  const currentPath = process.env[pathKey];
+  const delimiter2 = process.platform === "win32" ? ";" : ":";
+  return {
+    ...process.env,
+    [pathKey]: currentPath && currentPath.length > 0 ? `${pathEntry}${delimiter2}${currentPath}` : pathEntry
+  };
+}
+function runWindowsBatchCommand(command, args, cwd) {
+  const result2 = (0, import_node_child_process3.spawnSync)((0, import_node_path4.normalize)(command), args, {
     cwd,
-    stdio,
-    shell: false,
-    windowsVerbatimArguments: true
+    stdio: "inherit",
+    shell: false
   });
+  if (typeof result2.status === "number" && result2.status !== 0) {
+    process.exit(result2.status);
+  }
 }
-function runCommand(command, args, cwd) {
+function runCommand(command, args, cwd, env) {
   const normalizedCommand = (0, import_node_path4.normalize)(command);
-  const result2 = process.platform === "win32" ? spawnWin32Safe(normalizedCommand, args, cwd, "inherit") : (0, import_node_child_process3.spawnSync)(normalizedCommand, args, { cwd, stdio: "inherit", shell: false });
+  const result2 = (0, import_node_child_process3.spawnSync)(normalizedCommand, args, { cwd, env, stdio: "inherit", shell: false });
   if (typeof result2.status === "number" && result2.status !== 0) {
     process.exit(result2.status);
   }
@@ -78555,8 +79074,1812 @@ Notes:
 `);
 }
 
+// src/pm-cli.ts
+var import_node_child_process4 = require("child_process");
+var import_node_fs5 = require("fs");
+var import_node_os2 = require("os");
+var import_node_path5 = require("path");
+var DEFAULT_PM_DATA_DIR = (0, import_node_path5.join)(".elit", "pm");
+var DEFAULT_PM_DUMP_FILE = "dump.json";
+var DEFAULT_RESTART_DELAY = 1e3;
+var DEFAULT_MAX_RESTARTS = 10;
+var DEFAULT_WATCH_DEBOUNCE = 250;
+var DEFAULT_MIN_UPTIME = 0;
+var DEFAULT_HEALTHCHECK_GRACE_PERIOD = 5e3;
+var DEFAULT_HEALTHCHECK_INTERVAL = 1e4;
+var DEFAULT_HEALTHCHECK_TIMEOUT = 3e3;
+var DEFAULT_HEALTHCHECK_MAX_FAILURES = 3;
+var DEFAULT_LOG_LINES = 40;
+var PM_RECORD_EXTENSION = ".json";
+var SUPPORTED_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"]);
+var DEFAULT_WATCH_IGNORE = ["**/.git/**", "**/node_modules/**", "**/.elit/**"];
+function normalizePmRuntime(value, optionName = "--runtime") {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new Error(`${optionName} must be one of: node, bun, deno`);
+  }
+  const runtime2 = value.trim().toLowerCase();
+  if (runtime2 === "node" || runtime2 === "bun" || runtime2 === "deno") {
+    return runtime2;
+  }
+  throw new Error(`${optionName} must be one of: node, bun, deno`);
+}
+function normalizePmRestartPolicy(value, optionName = "--restart-policy") {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new Error(`${optionName} must be one of: always, on-failure, never`);
+  }
+  const policy = value.trim().toLowerCase();
+  if (policy === "always" || policy === "on-failure" || policy === "never") {
+    return policy;
+  }
+  throw new Error(`${optionName} must be one of: always, on-failure, never`);
+}
+function normalizeIntegerOption(value, optionName, min2 = 0) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed < min2) {
+    throw new Error(`${optionName} must be a number >= ${min2}`);
+  }
+  return parsed;
+}
+function normalizeNonEmptyString2(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function hasPmGoogleDriveConfig(config) {
+  return Boolean(
+    normalizeNonEmptyString2(config?.fileId) || normalizeNonEmptyString2(config?.accessToken) || normalizeNonEmptyString2(config?.accessTokenEnv) || typeof config?.supportsAllDrives === "boolean"
+  );
+}
+function hasPmWapkRunConfig(config) {
+  return Boolean(
+    normalizeNonEmptyString2(config?.file) || hasPmGoogleDriveConfig(config?.googleDrive) || normalizeNonEmptyString2(config?.runtime) || typeof config?.syncInterval === "number" || typeof config?.useWatcher === "boolean" || typeof config?.watchArchive === "boolean" || typeof config?.archiveSyncInterval === "number" || normalizeNonEmptyString2(config?.password)
+  );
+}
+function mergePmWapkRunConfig(base, override) {
+  if (!base && !override) {
+    return void 0;
+  }
+  const googleDrive = hasPmGoogleDriveConfig(base?.googleDrive) || hasPmGoogleDriveConfig(override?.googleDrive) ? {
+    fileId: override?.googleDrive?.fileId ?? base?.googleDrive?.fileId,
+    accessToken: override?.googleDrive?.accessToken ?? base?.googleDrive?.accessToken,
+    accessTokenEnv: override?.googleDrive?.accessTokenEnv ?? base?.googleDrive?.accessTokenEnv,
+    supportsAllDrives: override?.googleDrive?.supportsAllDrives ?? base?.googleDrive?.supportsAllDrives
+  } : void 0;
+  const merged = {
+    file: override?.file ?? base?.file,
+    googleDrive,
+    runtime: override?.runtime ?? base?.runtime,
+    syncInterval: override?.syncInterval ?? base?.syncInterval,
+    useWatcher: override?.useWatcher ?? base?.useWatcher,
+    watchArchive: override?.watchArchive ?? base?.watchArchive,
+    archiveSyncInterval: override?.archiveSyncInterval ?? base?.archiveSyncInterval,
+    password: override?.password ?? base?.password
+  };
+  return hasPmWapkRunConfig(merged) ? merged : void 0;
+}
+function stripPmWapkSourceFromRunConfig(config) {
+  if (!config) {
+    return void 0;
+  }
+  const googleDrive = hasPmGoogleDriveConfig({
+    ...config.googleDrive,
+    fileId: void 0
+  }) ? {
+    ...config.googleDrive,
+    fileId: void 0
+  } : void 0;
+  const stripped = {
+    file: void 0,
+    googleDrive,
+    runtime: void 0,
+    syncInterval: config.syncInterval,
+    useWatcher: config.useWatcher,
+    watchArchive: config.watchArchive,
+    archiveSyncInterval: config.archiveSyncInterval,
+    password: void 0
+  };
+  return hasPmWapkRunConfig(stripped) ? stripped : void 0;
+}
+function isRemoteWapkArchiveSpecifier(value) {
+  return /^(?:gdrive|google-drive):\/\/.+/i.test(value.trim());
+}
+function isWapkArchiveSpecifier(value) {
+  const normalized = value.trim();
+  return normalized.toLowerCase().endsWith(".wapk") || isRemoteWapkArchiveSpecifier(normalized);
+}
+function buildGoogleDriveWapkSpecifier(fileId) {
+  return `gdrive://${fileId}`;
+}
+function resolvePmWapkSource(value, cwd) {
+  const normalized = normalizeNonEmptyString2(value);
+  if (!normalized) {
+    return void 0;
+  }
+  return isRemoteWapkArchiveSpecifier(normalized) ? normalized : (0, import_node_path5.resolve)(cwd, normalized);
+}
+function resolvePmWapkSourceToken(wapk, wapkRun) {
+  const googleDriveFileId = normalizeNonEmptyString2(wapkRun?.googleDrive?.fileId);
+  return normalizeNonEmptyString2(wapk) ?? normalizeNonEmptyString2(wapkRun?.file) ?? (googleDriveFileId ? buildGoogleDriveWapkSpecifier(googleDriveFileId) : void 0);
+}
+function countDefinedPmWapkSources(wapk, wapkRun) {
+  const values = [
+    normalizeNonEmptyString2(wapk),
+    normalizeNonEmptyString2(wapkRun?.file),
+    normalizeNonEmptyString2(wapkRun?.googleDrive?.fileId)
+  ].filter((entry) => Boolean(entry));
+  return new Set(values).size;
+}
+function appendPmWapkRunArgs(args, previewParts, wapkRun) {
+  if (!wapkRun) {
+    return;
+  }
+  if (typeof wapkRun.syncInterval === "number" && Number.isFinite(wapkRun.syncInterval) && wapkRun.syncInterval >= 50) {
+    const value = String(Math.trunc(wapkRun.syncInterval));
+    args.push("--sync-interval", value);
+    previewParts.push("--sync-interval", value);
+  }
+  if (wapkRun.useWatcher) {
+    args.push("--watcher");
+    previewParts.push("--watcher");
+  }
+  if (typeof wapkRun.watchArchive === "boolean") {
+    const flag = wapkRun.watchArchive ? "--archive-watch" : "--no-archive-watch";
+    args.push(flag);
+    previewParts.push(flag);
+  }
+  if (typeof wapkRun.archiveSyncInterval === "number" && Number.isFinite(wapkRun.archiveSyncInterval) && wapkRun.archiveSyncInterval >= 50) {
+    const value = String(Math.trunc(wapkRun.archiveSyncInterval));
+    args.push("--archive-sync-interval", value);
+    previewParts.push("--archive-sync-interval", value);
+  }
+  const tokenEnv = normalizeNonEmptyString2(wapkRun.googleDrive?.accessTokenEnv);
+  if (tokenEnv) {
+    args.push("--google-drive-token-env", tokenEnv);
+    previewParts.push("--google-drive-token-env", tokenEnv);
+  }
+  const accessToken = normalizeNonEmptyString2(wapkRun.googleDrive?.accessToken);
+  if (accessToken) {
+    args.push("--google-drive-access-token", accessToken);
+    previewParts.push("--google-drive-access-token", "******");
+  }
+  if (wapkRun.googleDrive?.supportsAllDrives) {
+    args.push("--google-drive-shared-drive");
+    previewParts.push("--google-drive-shared-drive");
+  }
+}
+function buildPmWapkPreview(wapk, runtime2, password, wapkRun) {
+  const previewParts = ["elit", "wapk", "run", quoteCommandSegment(wapk)];
+  if (runtime2) {
+    previewParts.push("--runtime", runtime2);
+  }
+  if (password) {
+    previewParts.push("--password", "******");
+  }
+  appendPmWapkRunArgs([], previewParts, wapkRun);
+  return previewParts.join(" ");
+}
+function sanitizePmProcessName(name) {
+  const sanitized = name.trim().toLowerCase().replace(/[<>:"/\\|?*\x00-\x1f]+/g, "-").replace(/\s+/g, "-").replace(/-+/g, "-");
+  return sanitized.length > 0 ? sanitized : "process";
+}
+function isTypescriptFile(filePath) {
+  const extension = (0, import_node_path5.extname)(filePath).toLowerCase();
+  return extension === ".ts" || extension === ".mts" || extension === ".cts";
+}
+function normalizeStringArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+}
+function toWatchGlob(candidatePath) {
+  if (!(0, import_node_fs5.existsSync)(candidatePath)) {
+    return candidatePath;
+  }
+  try {
+    return (0, import_node_fs5.statSync)(candidatePath).isDirectory() ? (0, import_node_path5.join)(candidatePath, "**", "*").replace(/\\/g, "/") : candidatePath;
+  } catch {
+    return candidatePath;
+  }
+}
+function normalizeWatchPatterns(paths, cwd) {
+  return paths.map((entry) => (0, import_node_path5.resolve)(cwd, entry)).map(toWatchGlob).map((entry) => entry.replace(/\\/g, "/"));
+}
+function normalizeWatchIgnorePatterns(paths, cwd) {
+  return paths.map((entry) => entry.trim()).filter((entry) => entry.length > 0).map((entry) => {
+    if (entry.includes("*") || entry.includes("?")) {
+      return entry.replace(/\\/g, "/");
+    }
+    const resolvedPath = (0, import_node_path5.resolve)(cwd, entry);
+    return toWatchGlob(resolvedPath).replace(/\\/g, "/");
+  });
+}
+function matchesGlobPattern(filePath, pattern) {
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  const normalizedPattern = pattern.replace(/\\/g, "/");
+  const regexPattern = normalizedPattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/\?/g, ".");
+  return new RegExp(`^${regexPattern}$`).test(normalizedPath);
+}
+function isIgnoredWatchPath(filePath, patterns) {
+  return patterns.some((pattern) => matchesGlobPattern(filePath, pattern));
+}
+function normalizeHealthCheckConfig(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const config = value;
+  if (typeof config.url !== "string" || config.url.trim().length === 0) {
+    return void 0;
+  }
+  return {
+    url: config.url.trim(),
+    gracePeriod: typeof config.gracePeriod === "number" && Number.isFinite(config.gracePeriod) ? Math.max(0, Math.trunc(config.gracePeriod)) : DEFAULT_HEALTHCHECK_GRACE_PERIOD,
+    interval: typeof config.interval === "number" && Number.isFinite(config.interval) ? Math.max(250, Math.trunc(config.interval)) : DEFAULT_HEALTHCHECK_INTERVAL,
+    timeout: typeof config.timeout === "number" && Number.isFinite(config.timeout) ? Math.max(250, Math.trunc(config.timeout)) : DEFAULT_HEALTHCHECK_TIMEOUT,
+    maxFailures: typeof config.maxFailures === "number" && Number.isFinite(config.maxFailures) ? Math.max(1, Math.trunc(config.maxFailures)) : DEFAULT_HEALTHCHECK_MAX_FAILURES
+  };
+}
+function looksLikeManagedFile(value, cwd) {
+  const normalized = value.trim();
+  if (!normalized) {
+    return false;
+  }
+  if (isRemoteWapkArchiveSpecifier(normalized)) {
+    return false;
+  }
+  if (normalized.toLowerCase().endsWith(".wapk")) {
+    return true;
+  }
+  const extension = (0, import_node_path5.extname)(normalized).toLowerCase();
+  if (SUPPORTED_FILE_EXTENSIONS.has(extension)) {
+    return true;
+  }
+  if (normalized.includes("/") || normalized.includes("\\") || normalized.startsWith(".")) {
+    return (0, import_node_fs5.existsSync)((0, import_node_path5.resolve)(cwd, normalized));
+  }
+  return false;
+}
+function normalizeEnvMap(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  const normalized = {};
+  for (const [key, entryValue] of Object.entries(value)) {
+    if (typeof entryValue === "string") {
+      normalized[key] = entryValue;
+      continue;
+    }
+    if (typeof entryValue === "number" || typeof entryValue === "boolean") {
+      normalized[key] = String(entryValue);
+    }
+  }
+  return normalized;
+}
+function parsePmEnvEntry(input) {
+  const separatorIndex = input.indexOf("=");
+  if (separatorIndex <= 0) {
+    throw new Error("--env expects KEY=VALUE");
+  }
+  const key = input.slice(0, separatorIndex).trim();
+  const value = input.slice(separatorIndex + 1);
+  if (!key) {
+    throw new Error("--env expects KEY=VALUE");
+  }
+  return [key, value];
+}
+function readRequiredValue(args, index, optionName) {
+  const value = args[index];
+  if (value === void 0) {
+    throw new Error(`${optionName} requires a value.`);
+  }
+  return value;
+}
+function parsePmTarget(parsed, workspaceRoot) {
+  if (parsed.script) {
+    return { script: parsed.script };
+  }
+  if (parsed.file) {
+    return { file: parsed.file };
+  }
+  if (parsed.wapk) {
+    return { wapk: parsed.wapk };
+  }
+  if (!parsed.targetToken) {
+    return {};
+  }
+  if (isWapkArchiveSpecifier(parsed.targetToken)) {
+    return { wapk: parsed.targetToken };
+  }
+  if (looksLikeManagedFile(parsed.targetToken, (0, import_node_path5.resolve)(workspaceRoot, parsed.cwd ?? "."))) {
+    return { file: parsed.targetToken };
+  }
+  return { configName: parsed.targetToken };
+}
+function getConfiguredPmApps(config) {
+  return Array.isArray(config?.pm?.apps) ? config.pm.apps : [];
+}
+function defaultProcessName(base, explicitName) {
+  if (explicitName && explicitName.trim()) {
+    return explicitName.trim();
+  }
+  if (base.file) {
+    const fileName = (0, import_node_path5.basename)(base.file, (0, import_node_path5.extname)(base.file));
+    return fileName || "process";
+  }
+  if (base.wapk) {
+    const fileName = (0, import_node_path5.basename)(base.wapk, (0, import_node_path5.extname)(base.wapk));
+    return fileName || "wapk-app";
+  }
+  if (base.script) {
+    const candidate = base.script.trim().split(/\s+/).slice(0, 2).join("-");
+    return candidate || "process";
+  }
+  return "process";
+}
+function countDefinedTargets(app) {
+  return [app.script, app.file, app.wapk].filter(Boolean).length;
+}
+function resolvePmPaths(config, workspaceRoot) {
+  const dataDir = (0, import_node_path5.resolve)(workspaceRoot, config?.dataDir ?? DEFAULT_PM_DATA_DIR);
+  const dumpFile = config?.dumpFile ? (0, import_node_path5.resolve)(workspaceRoot, config.dumpFile) : (0, import_node_path5.join)(dataDir, DEFAULT_PM_DUMP_FILE);
+  return {
+    dataDir,
+    appsDir: (0, import_node_path5.join)(dataDir, "apps"),
+    logsDir: (0, import_node_path5.join)(dataDir, "logs"),
+    dumpFile
+  };
+}
+function ensurePmDirectories(paths) {
+  (0, import_node_fs5.mkdirSync)(paths.dataDir, { recursive: true });
+  (0, import_node_fs5.mkdirSync)(paths.appsDir, { recursive: true });
+  (0, import_node_fs5.mkdirSync)(paths.logsDir, { recursive: true });
+  (0, import_node_fs5.mkdirSync)((0, import_node_path5.dirname)(paths.dumpFile), { recursive: true });
+}
+function getPmRecordPath(paths, id) {
+  return (0, import_node_path5.join)(paths.appsDir, `${id}${PM_RECORD_EXTENSION}`);
+}
+function readPmRecord(filePath) {
+  return JSON.parse((0, import_node_fs5.readFileSync)(filePath, "utf8"));
+}
+function writePmRecord(filePath, record) {
+  (0, import_node_fs5.writeFileSync)(filePath, JSON.stringify(record, null, 2));
+}
+function toSavedAppDefinition(record) {
+  return {
+    name: record.name,
+    type: record.type,
+    cwd: record.cwd,
+    runtime: record.runtime,
+    env: record.env,
+    script: record.script,
+    file: record.file,
+    wapk: record.wapk,
+    password: record.password,
+    wapkRun: record.wapkRun,
+    restartPolicy: record.restartPolicy,
+    autorestart: record.autorestart,
+    restartDelay: record.restartDelay,
+    maxRestarts: record.maxRestarts,
+    minUptime: record.minUptime,
+    watch: record.watch,
+    watchPaths: record.watchPaths,
+    watchIgnore: record.watchIgnore,
+    watchDebounce: record.watchDebounce,
+    healthCheck: record.healthCheck
+  };
+}
+function writePmDumpFile(filePath, apps) {
+  const dump = {
+    version: 1,
+    savedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    apps
+  };
+  (0, import_node_fs5.writeFileSync)(filePath, JSON.stringify(dump, null, 2));
+}
+function readPmDumpFile(filePath) {
+  const parsed = JSON.parse((0, import_node_fs5.readFileSync)(filePath, "utf8"));
+  if (parsed.version !== 1 || !Array.isArray(parsed.apps)) {
+    throw new Error(`Invalid PM dump file: ${filePath}`);
+  }
+  return {
+    version: 1,
+    savedAt: typeof parsed.savedAt === "string" ? parsed.savedAt : (/* @__PURE__ */ new Date(0)).toISOString(),
+    apps: parsed.apps
+  };
+}
+function deriveDefaultWatchPaths(type, cwd, file, wapk) {
+  if (type === "file" && file) {
+    return [file];
+  }
+  if (type === "wapk" && wapk) {
+    return [isRemoteWapkArchiveSpecifier(wapk) ? cwd : wapk];
+  }
+  return [cwd];
+}
+function normalizeResolvedWatchPaths(paths, cwd, type, file, wapk) {
+  const sourcePaths = paths.length > 0 ? paths : deriveDefaultWatchPaths(type, cwd, file, wapk);
+  return normalizeWatchPatterns(sourcePaths, cwd);
+}
+function listPmRecordMatches(paths) {
+  if (!(0, import_node_fs5.existsSync)(paths.appsDir)) {
+    return [];
+  }
+  return (0, import_node_fs5.readdirSync)(paths.appsDir).filter((entry) => entry.endsWith(PM_RECORD_EXTENSION)).map((entry) => {
+    const filePath = (0, import_node_path5.join)(paths.appsDir, entry);
+    return {
+      filePath,
+      record: readPmRecord(filePath)
+    };
+  }).sort((left, right) => left.record.name.localeCompare(right.record.name));
+}
+function findPmRecordMatch(paths, nameOrId) {
+  const directPath = getPmRecordPath(paths, sanitizePmProcessName(nameOrId));
+  if ((0, import_node_fs5.existsSync)(directPath)) {
+    return {
+      filePath: directPath,
+      record: readPmRecord(directPath)
+    };
+  }
+  return listPmRecordMatches(paths).find((match) => match.record.name === nameOrId);
+}
+function isProcessAlive(pid) {
+  if (!pid || pid <= 0) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const code = error.code;
+    return code === "EPERM";
+  }
+}
+function syncPmRecordLiveness(match) {
+  const { record } = match;
+  if (record.desiredState === "running" && record.runnerPid && !isProcessAlive(record.runnerPid)) {
+    const updated = {
+      ...record,
+      status: record.status === "stopping" ? "stopped" : record.status === "errored" ? "errored" : "exited",
+      runnerPid: void 0,
+      childPid: void 0,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    writePmRecord(match.filePath, updated);
+    return { ...match, record: updated };
+  }
+  if (record.childPid && !isProcessAlive(record.childPid)) {
+    const updated = {
+      ...record,
+      childPid: void 0,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    writePmRecord(match.filePath, updated);
+    return { ...match, record: updated };
+  }
+  return match;
+}
+function readCurrentCliInvocation() {
+  const cliEntry = process.argv[1];
+  if (!cliEntry) {
+    throw new Error("Unable to resolve the current Elit CLI entrypoint for pm runner startup.");
+  }
+  return {
+    command: process.execPath,
+    args: [...process.execArgv, cliEntry]
+  };
+}
+function preferCurrentExecutable(runtime2) {
+  const executableName = (0, import_node_path5.basename)(process.execPath).toLowerCase();
+  if (runtime2 === "node" && process.release?.name === "node" && executableName.startsWith("node")) {
+    return process.execPath;
+  }
+  if (runtime2 === "bun" && process.versions?.bun && executableName.startsWith("bun")) {
+    return process.execPath;
+  }
+  return runtime2;
+}
+function commandExists2(command) {
+  if (command.includes("\\") || command.includes("/")) {
+    return (0, import_node_fs5.existsSync)(command);
+  }
+  const result2 = (0, import_node_child_process4.spawnSync)(command, ["--version"], {
+    stdio: "ignore",
+    windowsHide: true
+  });
+  return !result2.error;
+}
+function ensureCommandAvailable(command, displayName) {
+  if (commandExists2(command)) {
+    return;
+  }
+  throw new Error(`${displayName} was not found in PATH.`);
+}
+function resolveTsxExecutable(cwd) {
+  const localPath = (0, import_node_path5.join)(cwd, "node_modules", ".bin", process.platform === "win32" ? "tsx.cmd" : "tsx");
+  if ((0, import_node_fs5.existsSync)(localPath)) {
+    return localPath;
+  }
+  const globalCommand = process.platform === "win32" ? "tsx.cmd" : "tsx";
+  return commandExists2(globalCommand) ? globalCommand : void 0;
+}
+function inferRuntimeFromFile(filePath) {
+  if (isTypescriptFile(filePath) && commandExists2("bun")) {
+    return "bun";
+  }
+  return "node";
+}
+var SIMPLE_PREVIEW_SEGMENT = /^[A-Za-z0-9_./:=+-]+$/;
+function quoteCommandSegment(value) {
+  return SIMPLE_PREVIEW_SEGMENT.test(value) ? value : JSON.stringify(value);
+}
+function buildPmCommand(record) {
+  if (record.type === "script") {
+    return {
+      command: record.script,
+      args: [],
+      shell: true,
+      runtime: record.runtime,
+      preview: record.script
+    };
+  }
+  if (record.type === "wapk") {
+    const cliInvocation = readCurrentCliInvocation();
+    const args = [
+      ...cliInvocation.args,
+      "wapk",
+      "run",
+      record.wapk
+    ];
+    const previewParts = ["elit", "wapk", "run", quoteCommandSegment(record.wapk)];
+    if (record.runtime) {
+      args.push("--runtime", record.runtime);
+      previewParts.push("--runtime", record.runtime);
+    }
+    if (record.password) {
+      args.push("--password", record.password);
+      previewParts.push("--password", "******");
+    }
+    appendPmWapkRunArgs(args, previewParts, record.wapkRun);
+    return {
+      command: cliInvocation.command,
+      args,
+      preview: previewParts.join(" "),
+      runtime: record.runtime
+    };
+  }
+  const runtime2 = record.runtime ?? inferRuntimeFromFile(record.file);
+  if (runtime2 === "bun") {
+    const executable2 = preferCurrentExecutable("bun");
+    ensureCommandAvailable(executable2, "Bun runtime");
+    return {
+      command: executable2,
+      args: ["run", record.file],
+      runtime: runtime2,
+      preview: `${(0, import_node_path5.basename)(executable2)} run ${quoteCommandSegment(record.file)}`
+    };
+  }
+  if (runtime2 === "deno") {
+    const executable2 = preferCurrentExecutable("deno");
+    ensureCommandAvailable(executable2, "Deno runtime");
+    return {
+      command: executable2,
+      args: ["run", "--allow-all", record.file],
+      runtime: runtime2,
+      preview: `${(0, import_node_path5.basename)(executable2)} run --allow-all ${quoteCommandSegment(record.file)}`
+    };
+  }
+  if (isTypescriptFile(record.file)) {
+    const tsxExecutable = resolveTsxExecutable(record.cwd);
+    if (!tsxExecutable) {
+      throw new Error('TypeScript file execution with runtime "node" requires tsx to be installed, or use --runtime bun.');
+    }
+    return {
+      command: tsxExecutable,
+      args: [record.file],
+      runtime: runtime2,
+      preview: `${(0, import_node_path5.basename)(tsxExecutable)} ${quoteCommandSegment(record.file)}`
+    };
+  }
+  const executable = preferCurrentExecutable("node");
+  ensureCommandAvailable(executable, "Node.js runtime");
+  return {
+    command: executable,
+    args: [record.file],
+    runtime: runtime2,
+    preview: `${(0, import_node_path5.basename)(executable)} ${quoteCommandSegment(record.file)}`
+  };
+}
+function createRecordFromDefinition(definition, paths, existing) {
+  const id = sanitizePmProcessName(definition.name);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const preview = definition.type === "script" ? definition.script : definition.type === "wapk" ? buildPmWapkPreview(definition.wapk, definition.runtime, definition.password, definition.wapkRun) : `${definition.runtime ?? "auto"} ${quoteCommandSegment(definition.file)}`;
+  return {
+    id,
+    name: definition.name,
+    type: definition.type,
+    source: definition.source,
+    cwd: definition.cwd,
+    runtime: definition.runtime,
+    env: definition.env,
+    script: definition.script,
+    file: definition.file,
+    wapk: definition.wapk,
+    wapkRun: definition.wapkRun,
+    autorestart: definition.autorestart,
+    restartDelay: definition.restartDelay,
+    maxRestarts: definition.maxRestarts,
+    password: definition.password,
+    restartPolicy: definition.restartPolicy,
+    minUptime: definition.minUptime,
+    watch: definition.watch,
+    watchPaths: definition.watchPaths,
+    watchIgnore: definition.watchIgnore,
+    watchDebounce: definition.watchDebounce,
+    healthCheck: definition.healthCheck,
+    desiredState: "running",
+    status: "starting",
+    commandPreview: preview,
+    createdAt: existing?.createdAt ?? now,
+    updatedAt: now,
+    startedAt: void 0,
+    stoppedAt: void 0,
+    runnerPid: void 0,
+    childPid: void 0,
+    restartCount: existing?.restartCount ?? 0,
+    lastExitCode: existing?.lastExitCode,
+    error: void 0,
+    logFiles: existing?.logFiles ?? {
+      out: (0, import_node_path5.join)(paths.logsDir, `${id}.out.log`),
+      err: (0, import_node_path5.join)(paths.logsDir, `${id}.err.log`)
+    }
+  };
+}
+function terminateProcessTree(pid) {
+  if (process.platform === "win32") {
+    const result2 = (0, import_node_child_process4.spawnSync)("taskkill", ["/PID", String(pid), "/T", "/F"], {
+      stdio: "ignore",
+      windowsHide: true
+    });
+    if (result2.error && result2.error.code !== "ENOENT") {
+      throw result2.error;
+    }
+    return;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch (error) {
+    const code = error.code;
+    if (code !== "ESRCH") {
+      throw error;
+    }
+  }
+}
+async function startManagedProcess(definition, paths) {
+  ensurePmDirectories(paths);
+  const id = sanitizePmProcessName(definition.name);
+  const recordPath = getPmRecordPath(paths, id);
+  const existingMatch = (0, import_node_fs5.existsSync)(recordPath) ? syncPmRecordLiveness({ filePath: recordPath, record: readPmRecord(recordPath) }) : void 0;
+  if (existingMatch?.record.runnerPid && isProcessAlive(existingMatch.record.runnerPid)) {
+    throw new Error(`Process "${definition.name}" is already running.`);
+  }
+  const record = createRecordFromDefinition(definition, paths, existingMatch?.record);
+  writePmRecord(recordPath, record);
+  const cliInvocation = readCurrentCliInvocation();
+  const runner = (0, import_node_child_process4.spawn)(cliInvocation.command, [
+    ...cliInvocation.args,
+    "pm",
+    "__run",
+    "--data-dir",
+    paths.dataDir,
+    "--id",
+    record.id
+  ], {
+    cwd: definition.cwd,
+    detached: true,
+    stdio: "ignore",
+    windowsHide: true,
+    env: {
+      ...process.env,
+      ELIT_PM_INTERNAL: "1"
+    }
+  });
+  if (!runner.pid) {
+    throw new Error(`Failed to start process runner for "${definition.name}".`);
+  }
+  runner.unref();
+  const startedRecord = {
+    ...record,
+    runnerPid: runner.pid,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writePmRecord(recordPath, startedRecord);
+  return startedRecord;
+}
+function readLatestPmRecord(filePath, fallback) {
+  return (0, import_node_fs5.existsSync)(filePath) ? readPmRecord(filePath) : fallback;
+}
+function writePmLog(stream, message) {
+  stream.write(`[elit pm] ${(/* @__PURE__ */ new Date()).toISOString()} ${message}${import_node_os2.EOL}`);
+}
+function waitForExit(code, signal) {
+  if (typeof code === "number") {
+    return code;
+  }
+  if (signal === "SIGINT" || signal === "SIGTERM") {
+    return 0;
+  }
+  return 1;
+}
+async function delay(milliseconds) {
+  await new Promise((resolvePromise) => setTimeout(resolvePromise, milliseconds));
+}
+async function waitForManagedChildExit(child) {
+  return await new Promise((resolvePromise) => {
+    let resolved = false;
+    child.once("error", (error) => {
+      if (resolved) {
+        return;
+      }
+      resolved = true;
+      resolvePromise({ code: 1, signal: null, error: error instanceof Error ? error.message : String(error) });
+    });
+    child.once("close", (code, signal) => {
+      if (resolved) {
+        return;
+      }
+      resolved = true;
+      resolvePromise({ code, signal });
+    });
+  });
+}
+async function createPmWatchController(record, onChange, onError) {
+  if (!record.watch || record.watchPaths.length === 0) {
+    return {
+      async close() {
+      }
+    };
+  }
+  const watcher = watch(record.watchPaths);
+  let debounceTimer = null;
+  const scheduleRestart = (filePath) => {
+    const normalizedPath = filePath.replace(/\\/g, "/");
+    if (isIgnoredWatchPath(normalizedPath, record.watchIgnore)) {
+      return;
+    }
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+    }
+    debounceTimer = setTimeout(() => {
+      debounceTimer = null;
+      onChange(normalizedPath);
+    }, record.watchDebounce);
+    debounceTimer.unref?.();
+  };
+  watcher.on("add", scheduleRestart);
+  watcher.on("change", scheduleRestart);
+  watcher.on("unlink", scheduleRestart);
+  watcher.on("error", (error) => onError(error instanceof Error ? error.message : String(error)));
+  return {
+    async close() {
+      if (debounceTimer) {
+        clearTimeout(debounceTimer);
+        debounceTimer = null;
+      }
+      await watcher.close();
+    }
+  };
+}
+function createPmHealthMonitor(record, onFailure, onLog) {
+  if (!record.healthCheck) {
+    return {
+      stop() {
+      }
+    };
+  }
+  const healthCheck = record.healthCheck;
+  let stopped = false;
+  let timer = null;
+  let initialDelay = null;
+  let inFlight = false;
+  let failureCount = 0;
+  const runHealthCheck = async () => {
+    if (stopped || inFlight) {
+      return;
+    }
+    inFlight = true;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), healthCheck.timeout);
+    timeoutId.unref?.();
+    try {
+      const response = await fetch(healthCheck.url, {
+        method: "GET",
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(`health check returned ${response.status}`);
+      }
+      failureCount = 0;
+    } catch (error) {
+      failureCount += 1;
+      const message = error instanceof Error ? error.message : String(error);
+      onLog(`health check failed (${failureCount}/${healthCheck.maxFailures}): ${message}`);
+      if (failureCount >= healthCheck.maxFailures) {
+        stopped = true;
+        onFailure(`health check failed ${failureCount} times: ${message}`);
+      }
+    } finally {
+      clearTimeout(timeoutId);
+      inFlight = false;
+    }
+  };
+  initialDelay = setTimeout(() => {
+    void runHealthCheck();
+    timer = setInterval(() => {
+      void runHealthCheck();
+    }, healthCheck.interval);
+    timer.unref?.();
+  }, healthCheck.gracePeriod);
+  initialDelay.unref?.();
+  return {
+    stop() {
+      stopped = true;
+      if (initialDelay) {
+        clearTimeout(initialDelay);
+        initialDelay = null;
+      }
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+    }
+  };
+}
+function readPlannedRestartRequest(state) {
+  return state.request;
+}
+async function runManagedProcessLoop(filePath, initialRecord) {
+  let record = initialRecord;
+  let activeChild = null;
+  let stopRequested = false;
+  const restartState = { request: null };
+  (0, import_node_fs5.mkdirSync)((0, import_node_path5.dirname)(initialRecord.logFiles.out), { recursive: true });
+  (0, import_node_fs5.mkdirSync)((0, import_node_path5.dirname)(initialRecord.logFiles.err), { recursive: true });
+  const stdoutLog = (0, import_node_fs5.createWriteStream)(initialRecord.logFiles.out, { flags: "a" });
+  const stderrLog = (0, import_node_fs5.createWriteStream)(initialRecord.logFiles.err, { flags: "a" });
+  const persist = (mutator) => {
+    const current = readLatestPmRecord(filePath, record);
+    record = mutator(current);
+    writePmRecord(filePath, record);
+    return record;
+  };
+  const stopActiveChild = () => {
+    if (activeChild?.pid && isProcessAlive(activeChild.pid)) {
+      terminateProcessTree(activeChild.pid);
+    }
+  };
+  const handleStopSignal = (signal) => {
+    stopRequested = true;
+    persist((current) => ({
+      ...current,
+      desiredState: "stopped",
+      status: "stopping",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }));
+    writePmLog(stdoutLog, `received ${signal}, stopping managed process`);
+    stopActiveChild();
+  };
+  process.on("SIGINT", handleStopSignal);
+  process.on("SIGTERM", handleStopSignal);
+  persist((current) => ({
+    ...current,
+    runnerPid: process.pid,
+    desiredState: "running",
+    status: "starting",
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  }));
+  try {
+    while (!stopRequested) {
+      restartState.request = null;
+      const latest = readLatestPmRecord(filePath, record);
+      if (latest.desiredState === "stopped") {
+        break;
+      }
+      let command;
+      try {
+        command = buildPmCommand(latest);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        writePmLog(stderrLog, message);
+        persist((current2) => ({
+          ...current2,
+          status: "errored",
+          error: message,
+          runnerPid: void 0,
+          childPid: void 0,
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }));
+        return;
+      }
+      const child = (0, import_node_child_process4.spawn)(command.command, command.args, {
+        cwd: latest.cwd,
+        env: {
+          ...process.env,
+          ...latest.env,
+          ELIT_PM_NAME: latest.name,
+          ELIT_PM_ID: latest.id
+        },
+        stdio: ["ignore", "pipe", "pipe"],
+        windowsHide: true,
+        shell: command.shell
+      });
+      const childStartedAt = Date.now();
+      activeChild = child;
+      if (child.stdout) {
+        child.stdout.pipe(stdoutLog, { end: false });
+      }
+      if (child.stderr) {
+        child.stderr.pipe(stderrLog, { end: false });
+      }
+      const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+      persist((current2) => ({
+        ...current2,
+        status: "online",
+        commandPreview: command.preview,
+        runtime: command.runtime ?? current2.runtime,
+        runnerPid: process.pid,
+        childPid: child.pid,
+        startedAt,
+        stoppedAt: void 0,
+        error: void 0,
+        updatedAt: startedAt
+      }));
+      writePmLog(stdoutLog, `started ${command.preview}${child.pid ? ` (pid ${child.pid})` : ""}`);
+      const requestPlannedRestart = (kind, detail) => {
+        if (stopRequested || restartState.request) {
+          return;
+        }
+        restartState.request = { kind, detail };
+        writePmLog(kind === "health" ? stderrLog : stdoutLog, `${kind} restart requested: ${detail}`);
+        persist((current2) => ({
+          ...current2,
+          status: "restarting",
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }));
+        stopActiveChild();
+      };
+      const watchController = await createPmWatchController(
+        latest,
+        (changedPath) => requestPlannedRestart("watch", changedPath),
+        (message) => writePmLog(stderrLog, `watch error: ${message}`)
+      );
+      const healthMonitor = createPmHealthMonitor(
+        latest,
+        (message) => requestPlannedRestart("health", message),
+        (message) => writePmLog(stdoutLog, message)
+      );
+      const exitResult = await waitForManagedChildExit(child);
+      await watchController.close();
+      healthMonitor.stop();
+      activeChild = null;
+      const exitCode = waitForExit(exitResult.code, exitResult.signal);
+      const current = readLatestPmRecord(filePath, record);
+      const plannedRestart = readPlannedRestartRequest(restartState);
+      const uptime = Math.max(0, Date.now() - childStartedAt);
+      const wasStable = current.minUptime > 0 && uptime >= current.minUptime;
+      if (exitResult.error) {
+        writePmLog(stderrLog, exitResult.error);
+      } else if (!plannedRestart) {
+        writePmLog(stdoutLog, `process exited with code ${exitCode}`);
+      }
+      if (stopRequested || current.desiredState === "stopped") {
+        break;
+      }
+      const shouldRestartForExit = plannedRestart ? true : current.restartPolicy === "always" ? true : current.restartPolicy === "on-failure" ? exitCode !== 0 || Boolean(exitResult.error) : false;
+      if (!shouldRestartForExit) {
+        persist((latestRecord) => ({
+          ...latestRecord,
+          status: exitCode === 0 && !exitResult.error ? "exited" : "errored",
+          childPid: void 0,
+          runnerPid: void 0,
+          lastExitCode: exitCode,
+          error: exitCode === 0 && !exitResult.error ? void 0 : exitResult.error ?? `Process exited with code ${exitCode}.`,
+          stoppedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }));
+        return;
+      }
+      const shouldCountRestart = plannedRestart?.kind !== "watch";
+      const baseRestartCount = wasStable ? 0 : current.restartCount ?? 0;
+      const nextRestartCount = shouldCountRestart ? baseRestartCount + 1 : current.restartCount ?? 0;
+      if (nextRestartCount > current.maxRestarts) {
+        persist((latestRecord) => ({
+          ...latestRecord,
+          status: "errored",
+          childPid: void 0,
+          runnerPid: void 0,
+          restartCount: nextRestartCount,
+          lastExitCode: exitCode,
+          error: plannedRestart ? `Reached max restart attempts (${current.maxRestarts}) after ${plannedRestart.kind} restart requests.` : `Reached max restart attempts (${current.maxRestarts}).`,
+          stoppedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }));
+        writePmLog(stderrLog, `max restart attempts reached (${current.maxRestarts})`);
+        return;
+      }
+      persist((latestRecord) => ({
+        ...latestRecord,
+        status: "restarting",
+        childPid: void 0,
+        lastExitCode: exitCode,
+        restartCount: nextRestartCount,
+        error: void 0,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }));
+      if (plannedRestart) {
+        writePmLog(
+          plannedRestart.kind === "health" ? stderrLog : stdoutLog,
+          `restarting in ${current.restartDelay}ms after ${plannedRestart.kind}: ${plannedRestart.detail}`
+        );
+      } else {
+        writePmLog(stdoutLog, `restarting in ${current.restartDelay}ms`);
+      }
+      await delay(current.restartDelay);
+    }
+  } finally {
+    stopRequested = true;
+    stopActiveChild();
+    const finalRecord = readLatestPmRecord(filePath, record);
+    writePmRecord(filePath, {
+      ...finalRecord,
+      desiredState: "stopped",
+      status: finalRecord.status === "errored" ? "errored" : finalRecord.status === "exited" ? "exited" : "stopped",
+      runnerPid: void 0,
+      childPid: void 0,
+      stoppedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    process.off("SIGINT", handleStopSignal);
+    process.off("SIGTERM", handleStopSignal);
+    await new Promise((resolvePromise) => stdoutLog.end(resolvePromise));
+    await new Promise((resolvePromise) => stderrLog.end(resolvePromise));
+  }
+}
+function resolveStartSelection(configApps, parsed, workspaceRoot) {
+  const target = parsePmTarget(parsed, workspaceRoot);
+  const hasExplicitWapkSource = Boolean(resolvePmWapkSourceToken(parsed.wapk, parsed.wapkRun));
+  const selectedName = target.configName ?? (!target.script && !target.file && !target.wapk && !hasExplicitWapkSource ? parsed.name : void 0);
+  const selected = selectedName ? configApps.find((app) => app.name === selectedName) : void 0;
+  return {
+    selected,
+    startAll: !target.script && !target.file && !target.wapk && !hasExplicitWapkSource && !selectedName,
+    target
+  };
+}
+function toPmAppConfig(record) {
+  return {
+    name: record.name,
+    script: record.script,
+    file: record.file,
+    wapk: record.wapk,
+    wapkRun: record.wapkRun,
+    runtime: record.runtime,
+    cwd: record.cwd,
+    env: record.env,
+    autorestart: record.autorestart,
+    restartDelay: record.restartDelay,
+    maxRestarts: record.maxRestarts,
+    password: record.password,
+    restartPolicy: record.restartPolicy,
+    minUptime: record.minUptime,
+    watch: record.watch,
+    watchPaths: record.watchPaths,
+    watchIgnore: record.watchIgnore,
+    watchDebounce: record.watchDebounce,
+    healthCheck: record.healthCheck
+  };
+}
+function toSavedPmAppConfig(app) {
+  return {
+    name: app.name,
+    script: app.script,
+    file: app.file,
+    wapk: app.wapk,
+    wapkRun: app.wapkRun,
+    runtime: app.runtime,
+    cwd: app.cwd,
+    env: app.env,
+    autorestart: app.autorestart,
+    restartDelay: app.restartDelay,
+    maxRestarts: app.maxRestarts,
+    password: app.password,
+    restartPolicy: app.restartPolicy,
+    minUptime: app.minUptime,
+    watch: app.watch,
+    watchPaths: app.watchPaths,
+    watchIgnore: app.watchIgnore,
+    watchDebounce: app.watchDebounce,
+    healthCheck: app.healthCheck
+  };
+}
+function resolvePmAppDefinition(base, parsed, workspaceRoot, source) {
+  const target = parsePmTarget(parsed, workspaceRoot);
+  const resolvedCwd = (0, import_node_path5.resolve)(workspaceRoot, parsed.cwd ?? base?.cwd ?? ".");
+  if (countDefinedPmWapkSources(parsed.wapk, parsed.wapkRun) > 1) {
+    throw new Error("Use only one WAPK archive source per pm start: --wapk or --google-drive-file-id.");
+  }
+  if (countDefinedPmWapkSources(base?.wapk, base?.wapkRun) > 1) {
+    throw new Error(`Configured pm app "${base?.name ?? parsed.name ?? "app"}" must define only one WAPK archive source.`);
+  }
+  const explicitWapk = resolvePmWapkSource(resolvePmWapkSourceToken(target.wapk, parsed.wapkRun), resolvedCwd);
+  const baseWapk = resolvePmWapkSource(resolvePmWapkSourceToken(base?.wapk, base?.wapkRun), resolvedCwd);
+  const hasExplicitTarget = Boolean(target.script || target.file || explicitWapk);
+  const script = target.script ?? (hasExplicitTarget ? void 0 : base?.script);
+  const file = target.file ? (0, import_node_path5.resolve)(resolvedCwd, target.file) : hasExplicitTarget ? void 0 : base?.file ? (0, import_node_path5.resolve)(resolvedCwd, base.file) : void 0;
+  const wapk = explicitWapk ?? (hasExplicitTarget ? void 0 : baseWapk);
+  const targetCount = countDefinedTargets({ script, file, wapk });
+  if (targetCount === 0) {
+    throw new Error("pm start requires one target: --script, --file, --wapk, or a configured app name.");
+  }
+  if (targetCount > 1) {
+    throw new Error("A pm app must define exactly one of script, file, or wapk.");
+  }
+  const name = defaultProcessName({ script, file, wapk }, parsed.name ?? base?.name);
+  const mergedWapkRun = mergePmWapkRunConfig(base?.wapkRun, parsed.wapkRun);
+  const runtime2 = normalizePmRuntime(parsed.runtime ?? mergedWapkRun?.runtime ?? base?.runtime, "--runtime");
+  let restartPolicy = normalizePmRestartPolicy(parsed.restartPolicy ?? base?.restartPolicy, "--restart-policy") ?? (base?.autorestart ?? true ? "always" : "never");
+  if (parsed.autorestart === false) {
+    restartPolicy = "never";
+  }
+  const autorestart = restartPolicy !== "never";
+  const watch4 = parsed.watch ?? base?.watch ?? false;
+  const configuredWatchPaths = parsed.watchPaths.length > 0 ? parsed.watchPaths : normalizeStringArray(base?.watchPaths);
+  const configuredWatchIgnore = [
+    ...DEFAULT_WATCH_IGNORE,
+    ...normalizeStringArray(base?.watchIgnore),
+    ...parsed.watchIgnore
+  ];
+  const healthCheck = normalizeHealthCheckConfig(parsed.healthCheckUrl ? {
+    url: parsed.healthCheckUrl,
+    gracePeriod: parsed.healthCheckGracePeriod,
+    interval: parsed.healthCheckInterval,
+    timeout: parsed.healthCheckTimeout,
+    maxFailures: parsed.healthCheckMaxFailures
+  } : base?.healthCheck);
+  const password = parsed.password ?? mergedWapkRun?.password ?? base?.password;
+  const wapkRun = stripPmWapkSourceFromRunConfig(mergedWapkRun);
+  if (password && !wapk) {
+    throw new Error("--password is only supported when starting a WAPK app.");
+  }
+  if (wapkRun && !wapk) {
+    throw new Error("WAPK run options are only supported when starting a WAPK app.");
+  }
+  return {
+    name,
+    type: script ? "script" : wapk ? "wapk" : "file",
+    source,
+    cwd: resolvedCwd,
+    runtime: runtime2,
+    env: {
+      ...normalizeEnvMap(base?.env),
+      ...parsed.env
+    },
+    script,
+    file,
+    wapk,
+    wapkRun,
+    autorestart,
+    restartDelay: parsed.restartDelay ?? base?.restartDelay ?? DEFAULT_RESTART_DELAY,
+    maxRestarts: parsed.maxRestarts ?? base?.maxRestarts ?? DEFAULT_MAX_RESTARTS,
+    password,
+    restartPolicy,
+    minUptime: parsed.minUptime ?? base?.minUptime ?? DEFAULT_MIN_UPTIME,
+    watch: watch4,
+    watchPaths: watch4 ? normalizeResolvedWatchPaths(configuredWatchPaths, resolvedCwd, script ? "script" : wapk ? "wapk" : "file", file, wapk) : [],
+    watchIgnore: watch4 ? normalizeWatchIgnorePatterns(configuredWatchIgnore, resolvedCwd) : [],
+    watchDebounce: parsed.watchDebounce ?? base?.watchDebounce ?? DEFAULT_WATCH_DEBOUNCE,
+    healthCheck
+  };
+}
+function resolvePmStartDefinitions(parsed, config, workspaceRoot) {
+  const configApps = getConfiguredPmApps(config);
+  const selection = resolveStartSelection(configApps, parsed, workspaceRoot);
+  if (selection.startAll) {
+    if (configApps.length === 0) {
+      throw new Error("No pm apps configured in elit.config.* and no start target was provided.");
+    }
+    return configApps.map((app) => resolvePmAppDefinition(app, { ...parsed, name: app.name }, workspaceRoot, "config"));
+  }
+  if (selection.selected) {
+    return [resolvePmAppDefinition(selection.selected, parsed, workspaceRoot, "config")];
+  }
+  return [resolvePmAppDefinition(void 0, parsed, workspaceRoot, "cli")];
+}
+function parsePmStartArgs(args) {
+  const parsed = {
+    env: {},
+    watchPaths: [],
+    watchIgnore: []
+  };
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    switch (arg) {
+      case "--script":
+        parsed.script = readRequiredValue(args, ++index, "--script");
+        break;
+      case "--file":
+      case "-f":
+        parsed.file = readRequiredValue(args, ++index, arg);
+        break;
+      case "--wapk":
+        parsed.wapk = readRequiredValue(args, ++index, "--wapk");
+        break;
+      case "--google-drive-file-id":
+        parsed.wapkRun = {
+          ...parsed.wapkRun,
+          googleDrive: {
+            ...parsed.wapkRun?.googleDrive,
+            fileId: readRequiredValue(args, ++index, "--google-drive-file-id")
+          }
+        };
+        break;
+      case "--google-drive-token-env":
+        parsed.wapkRun = {
+          ...parsed.wapkRun,
+          googleDrive: {
+            ...parsed.wapkRun?.googleDrive,
+            accessTokenEnv: readRequiredValue(args, ++index, "--google-drive-token-env")
+          }
+        };
+        break;
+      case "--google-drive-access-token":
+        parsed.wapkRun = {
+          ...parsed.wapkRun,
+          googleDrive: {
+            ...parsed.wapkRun?.googleDrive,
+            accessToken: readRequiredValue(args, ++index, "--google-drive-access-token")
+          }
+        };
+        break;
+      case "--google-drive-shared-drive":
+        parsed.wapkRun = {
+          ...parsed.wapkRun,
+          googleDrive: {
+            ...parsed.wapkRun?.googleDrive,
+            supportsAllDrives: true
+          }
+        };
+        break;
+      case "--runtime":
+      case "-r":
+        parsed.runtime = normalizePmRuntime(readRequiredValue(args, ++index, arg), arg);
+        break;
+      case "--name":
+      case "-n":
+        parsed.name = readRequiredValue(args, ++index, arg);
+        break;
+      case "--cwd":
+        parsed.cwd = readRequiredValue(args, ++index, "--cwd");
+        break;
+      case "--env": {
+        const [key, value] = parsePmEnvEntry(readRequiredValue(args, ++index, "--env"));
+        parsed.env[key] = value;
+        break;
+      }
+      case "--password":
+        parsed.password = readRequiredValue(args, ++index, "--password");
+        break;
+      case "--sync-interval":
+        parsed.wapkRun = {
+          ...parsed.wapkRun,
+          syncInterval: normalizeIntegerOption(readRequiredValue(args, ++index, "--sync-interval"), "--sync-interval", 50)
+        };
+        break;
+      case "--watcher":
+      case "--use-watcher":
+        parsed.wapkRun = {
+          ...parsed.wapkRun,
+          useWatcher: true
+        };
+        break;
+      case "--archive-watch":
+        parsed.wapkRun = {
+          ...parsed.wapkRun,
+          watchArchive: true
+        };
+        break;
+      case "--no-archive-watch":
+        parsed.wapkRun = {
+          ...parsed.wapkRun,
+          watchArchive: false
+        };
+        break;
+      case "--archive-sync-interval":
+        parsed.wapkRun = {
+          ...parsed.wapkRun,
+          archiveSyncInterval: normalizeIntegerOption(readRequiredValue(args, ++index, "--archive-sync-interval"), "--archive-sync-interval", 50)
+        };
+        break;
+      case "--restart-policy":
+        parsed.restartPolicy = normalizePmRestartPolicy(readRequiredValue(args, ++index, "--restart-policy"));
+        break;
+      case "--min-uptime":
+        parsed.minUptime = normalizeIntegerOption(readRequiredValue(args, ++index, "--min-uptime"), "--min-uptime");
+        break;
+      case "--watch":
+        parsed.watch = true;
+        break;
+      case "--watch-path":
+        parsed.watch = true;
+        parsed.watchPaths.push(readRequiredValue(args, ++index, "--watch-path"));
+        break;
+      case "--watch-ignore":
+        parsed.watch = true;
+        parsed.watchIgnore.push(readRequiredValue(args, ++index, "--watch-ignore"));
+        break;
+      case "--watch-debounce":
+        parsed.watch = true;
+        parsed.watchDebounce = normalizeIntegerOption(readRequiredValue(args, ++index, "--watch-debounce"), "--watch-debounce");
+        break;
+      case "--health-url":
+        parsed.healthCheckUrl = readRequiredValue(args, ++index, "--health-url");
+        break;
+      case "--health-grace-period":
+        parsed.healthCheckGracePeriod = normalizeIntegerOption(readRequiredValue(args, ++index, "--health-grace-period"), "--health-grace-period");
+        break;
+      case "--health-interval":
+        parsed.healthCheckInterval = normalizeIntegerOption(readRequiredValue(args, ++index, "--health-interval"), "--health-interval", 250);
+        break;
+      case "--health-timeout":
+        parsed.healthCheckTimeout = normalizeIntegerOption(readRequiredValue(args, ++index, "--health-timeout"), "--health-timeout", 250);
+        break;
+      case "--health-max-failures":
+        parsed.healthCheckMaxFailures = normalizeIntegerOption(readRequiredValue(args, ++index, "--health-max-failures"), "--health-max-failures", 1);
+        break;
+      case "--no-autorestart":
+        parsed.autorestart = false;
+        break;
+      case "--restart-delay":
+        parsed.restartDelay = normalizeIntegerOption(readRequiredValue(args, ++index, "--restart-delay"), "--restart-delay");
+        break;
+      case "--max-restarts":
+        parsed.maxRestarts = normalizeIntegerOption(readRequiredValue(args, ++index, "--max-restarts"), "--max-restarts");
+        break;
+      default:
+        if (arg.startsWith("-")) {
+          throw new Error(`Unknown pm option: ${arg}`);
+        }
+        if (parsed.targetToken) {
+          throw new Error("pm start accepts at most one positional target.");
+        }
+        parsed.targetToken = arg;
+        break;
+    }
+  }
+  if (countDefinedPmWapkSources(parsed.wapk, parsed.wapkRun) > 1) {
+    throw new Error("Use only one WAPK archive source per pm start: --wapk or --google-drive-file-id.");
+  }
+  const explicitTargets = [parsed.script, parsed.file, resolvePmWapkSourceToken(parsed.wapk, parsed.wapkRun)].filter(Boolean);
+  if (explicitTargets.length > 1) {
+    throw new Error("Use only one target type per pm start: --script, --file, or --wapk.");
+  }
+  if (parsed.healthCheckUrl && !/^https?:\/\//i.test(parsed.healthCheckUrl)) {
+    throw new Error("--health-url must be an absolute http:// or https:// URL");
+  }
+  return parsed;
+}
+function padCell(value, width) {
+  return value.length >= width ? value : `${value}${" ".repeat(width - value.length)}`;
+}
+function tailLogFile(filePath, lineCount) {
+  if (!(0, import_node_fs5.existsSync)(filePath)) {
+    return "";
+  }
+  const lines = (0, import_node_fs5.readFileSync)(filePath, "utf8").split(/\r?\n/).filter((line) => line.length > 0);
+  return lines.slice(-lineCount).join(import_node_os2.EOL);
+}
+function parseRunnerArgs(args) {
+  let dataDir;
+  let id;
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    switch (arg) {
+      case "--data-dir":
+        dataDir = readRequiredValue(args, ++index, "--data-dir");
+        break;
+      case "--id":
+        id = readRequiredValue(args, ++index, "--id");
+        break;
+      default:
+        throw new Error(`Unknown internal pm runner option: ${arg}`);
+    }
+  }
+  if (!dataDir || !id) {
+    throw new Error("Usage: elit pm __run --data-dir <dir> --id <name>");
+  }
+  return {
+    dataDir: (0, import_node_path5.resolve)(dataDir),
+    id
+  };
+}
+async function runPmRunner(args) {
+  const options = parseRunnerArgs(args);
+  const paths = {
+    dataDir: options.dataDir,
+    appsDir: (0, import_node_path5.join)(options.dataDir, "apps"),
+    logsDir: (0, import_node_path5.join)(options.dataDir, "logs"),
+    dumpFile: (0, import_node_path5.join)(options.dataDir, DEFAULT_PM_DUMP_FILE)
+  };
+  const match = findPmRecordMatch(paths, options.id);
+  if (!match) {
+    throw new Error(`PM record not found: ${options.id}`);
+  }
+  await runManagedProcessLoop(match.filePath, match.record);
+}
+async function runPmStart(args) {
+  const parsed = parsePmStartArgs(args);
+  const workspaceRoot = process.cwd();
+  const config = await loadConfig(workspaceRoot);
+  const paths = resolvePmPaths(config?.pm, workspaceRoot);
+  const definitions = resolvePmStartDefinitions(parsed, config, workspaceRoot);
+  const errors = [];
+  for (const definition of definitions) {
+    try {
+      const record = await startManagedProcess(definition, paths);
+      console.log(`[pm] started ${record.name} (${record.type})`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      errors.push(`[pm] ${definition.name}: ${message}`);
+    }
+  }
+  if (errors.length > 0) {
+    throw new Error(errors.join(import_node_os2.EOL));
+  }
+}
+async function loadPmContext() {
+  const workspaceRoot = process.cwd();
+  const config = await loadConfig(workspaceRoot);
+  return {
+    config,
+    paths: resolvePmPaths(config?.pm, workspaceRoot)
+  };
+}
+function resolveNamedMatches(paths, value) {
+  if (value === "all") {
+    return listPmRecordMatches(paths).map(syncPmRecordLiveness);
+  }
+  const match = findPmRecordMatch(paths, value);
+  return match ? [syncPmRecordLiveness(match)] : [];
+}
+function printPmList(paths) {
+  const matches2 = listPmRecordMatches(paths).map(syncPmRecordLiveness);
+  if (matches2.length === 0) {
+    console.log("No managed processes found.");
+    return;
+  }
+  const headers = [
+    padCell("name", 20),
+    padCell("status", 12),
+    padCell("pid", 8),
+    padCell("restarts", 10),
+    padCell("type", 8),
+    "runtime"
+  ];
+  console.log(headers.join("  "));
+  for (const { record } of matches2) {
+    console.log([
+      padCell(record.name, 20),
+      padCell(record.status, 12),
+      padCell(record.childPid ? String(record.childPid) : "-", 8),
+      padCell(String(record.restartCount ?? 0), 10),
+      padCell(record.type, 8),
+      record.runtime ?? "-"
+    ].join("  "));
+  }
+}
+function stopPmMatches(matches2) {
+  let stopped = 0;
+  for (const match of matches2) {
+    const current = syncPmRecordLiveness(match);
+    const updated = {
+      ...current.record,
+      desiredState: "stopped",
+      status: current.record.runnerPid ? "stopping" : "stopped",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      stoppedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    writePmRecord(current.filePath, updated);
+    if (current.record.runnerPid && isProcessAlive(current.record.runnerPid)) {
+      terminateProcessTree(current.record.runnerPid);
+    } else if (current.record.childPid && isProcessAlive(current.record.childPid)) {
+      terminateProcessTree(current.record.childPid);
+    }
+    writePmRecord(current.filePath, {
+      ...updated,
+      runnerPid: void 0,
+      childPid: void 0,
+      status: "stopped",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    stopped += 1;
+  }
+  return stopped;
+}
+async function runPmStop(args) {
+  const target = args[0];
+  if (!target) {
+    throw new Error("Usage: elit pm stop <name|all>");
+  }
+  const { paths } = await loadPmContext();
+  const matches2 = resolveNamedMatches(paths, target);
+  if (matches2.length === 0) {
+    throw new Error(`No managed process found for: ${target}`);
+  }
+  const count = stopPmMatches(matches2);
+  console.log(`[pm] stopped ${count} process${count === 1 ? "" : "es"}`);
+}
+async function runPmRestart(args) {
+  const target = args[0];
+  if (!target) {
+    throw new Error("Usage: elit pm restart <name|all>");
+  }
+  const { paths } = await loadPmContext();
+  const matches2 = resolveNamedMatches(paths, target);
+  if (matches2.length === 0) {
+    throw new Error(`No managed process found for: ${target}`);
+  }
+  stopPmMatches(matches2);
+  const restarted = [];
+  for (const match of matches2) {
+    const definition = resolvePmAppDefinition(
+      toPmAppConfig(match.record),
+      { name: match.record.name, env: {}, watchPaths: [], watchIgnore: [] },
+      process.cwd(),
+      match.record.source
+    );
+    await startManagedProcess(definition, paths);
+    restarted.push(match.record.name);
+  }
+  console.log(`[pm] restarted ${restarted.join(", ")}`);
+}
+async function runPmSave() {
+  const { paths } = await loadPmContext();
+  ensurePmDirectories(paths);
+  const runningApps = listPmRecordMatches(paths).map(syncPmRecordLiveness).filter((match) => match.record.desiredState === "running" && (match.record.status === "starting" || match.record.status === "online" || match.record.status === "restarting")).map((match) => toSavedAppDefinition(match.record));
+  writePmDumpFile(paths.dumpFile, runningApps);
+  console.log(`[pm] saved ${runningApps.length} process${runningApps.length === 1 ? "" : "es"} to ${paths.dumpFile}`);
+}
+async function runPmResurrect() {
+  const { paths } = await loadPmContext();
+  if (!(0, import_node_fs5.existsSync)(paths.dumpFile)) {
+    throw new Error(`PM dump file not found: ${paths.dumpFile}`);
+  }
+  const dump = readPmDumpFile(paths.dumpFile);
+  if (dump.apps.length === 0) {
+    console.log("[pm] dump file is empty, nothing to resurrect");
+    return;
+  }
+  const errors = [];
+  let restored = 0;
+  for (const app of dump.apps) {
+    try {
+      const definition = resolvePmAppDefinition(
+        toSavedPmAppConfig(app),
+        { name: app.name, env: {}, watchPaths: [], watchIgnore: [] },
+        process.cwd(),
+        "cli"
+      );
+      await startManagedProcess(definition, paths);
+      restored += 1;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      errors.push(`[pm] ${app.name}: ${message}`);
+    }
+  }
+  if (errors.length > 0) {
+    throw new Error([`[pm] resurrected ${restored} process${restored === 1 ? "" : "es"}`, ...errors].join(import_node_os2.EOL));
+  }
+  console.log(`[pm] resurrected ${restored} process${restored === 1 ? "" : "es"} from ${paths.dumpFile}`);
+}
+async function runPmDelete(args) {
+  const target = args[0];
+  if (!target) {
+    throw new Error("Usage: elit pm delete <name|all>");
+  }
+  const { paths } = await loadPmContext();
+  const matches2 = resolveNamedMatches(paths, target);
+  if (matches2.length === 0) {
+    throw new Error(`No managed process found for: ${target}`);
+  }
+  stopPmMatches(matches2);
+  for (const match of matches2) {
+    if ((0, import_node_fs5.existsSync)(match.record.logFiles.out)) {
+      (0, import_node_fs5.rmSync)(match.record.logFiles.out, { force: true });
+    }
+    if ((0, import_node_fs5.existsSync)(match.record.logFiles.err)) {
+      (0, import_node_fs5.rmSync)(match.record.logFiles.err, { force: true });
+    }
+    (0, import_node_fs5.rmSync)(match.filePath, { force: true });
+  }
+  console.log(`[pm] deleted ${matches2.length} process${matches2.length === 1 ? "" : "es"}`);
+}
+async function runPmLogs(args) {
+  if (args.length === 0) {
+    throw new Error("Usage: elit pm logs <name> [--lines <n>] [--stderr]");
+  }
+  let name;
+  let lineCount = DEFAULT_LOG_LINES;
+  let stderrOnly = false;
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    switch (arg) {
+      case "--lines":
+        lineCount = normalizeIntegerOption(readRequiredValue(args, ++index, "--lines"), "--lines", 1);
+        break;
+      case "--stderr":
+        stderrOnly = true;
+        break;
+      default:
+        if (arg.startsWith("-")) {
+          throw new Error(`Unknown pm logs option: ${arg}`);
+        }
+        if (name) {
+          throw new Error("pm logs accepts exactly one process name.");
+        }
+        name = arg;
+        break;
+    }
+  }
+  if (!name) {
+    throw new Error("Usage: elit pm logs <name> [--lines <n>] [--stderr]");
+  }
+  const { paths } = await loadPmContext();
+  const match = findPmRecordMatch(paths, name);
+  if (!match) {
+    throw new Error(`No managed process found for: ${name}`);
+  }
+  const stdoutContent = stderrOnly ? "" : tailLogFile(match.record.logFiles.out, lineCount);
+  const stderrContent = tailLogFile(match.record.logFiles.err, lineCount);
+  if (!stderrOnly) {
+    console.log(`== stdout: ${match.record.logFiles.out} ==`);
+    console.log(stdoutContent || "(empty)");
+  }
+  console.log(`== stderr: ${match.record.logFiles.err} ==`);
+  console.log(stderrContent || "(empty)");
+}
+function printPmHelp() {
+  console.log([
+    "",
+    "Elit PM - lightweight process manager",
+    "",
+    "Usage:",
+    '  elit pm start --script "npm start" --name my-app --runtime node',
+    "  elit pm start --wapk ./test.wapk --name my-app",
+    "  elit pm start --wapk gdrive://<fileId> --name my-app",
+    "  elit pm start --google-drive-file-id <fileId> --name my-app",
+    "  elit pm start ./app.ts --name my-app",
+    "  elit pm start --file ./app.js --name my-app",
+    "  elit pm start my-app",
+    "  elit pm start",
+    "  elit pm list",
+    "  elit pm stop <name|all>",
+    "  elit pm restart <name|all>",
+    "  elit pm delete <name|all>",
+    "  elit pm save",
+    "  elit pm resurrect",
+    "  elit pm logs <name> --lines 100",
+    "",
+    "Start Options:",
+    "  --script <command>          Run a shell command, for example: npm start",
+    "  --file, -f <path>           Run a .js/.mjs/.cjs/.ts file",
+    "  --wapk <source>             Run a local .wapk file or a remote source like gdrive://<fileId>",
+    "  --google-drive-file-id <id> Run a WAPK archive directly from Google Drive",
+    "  --google-drive-token-env <name>  Env var containing the Google Drive OAuth token",
+    "  --google-drive-access-token <value>  OAuth token forwarded to elit wapk run",
+    "  --google-drive-shared-drive Forward supportsAllDrives=true for shared drives",
+    "  --runtime, -r <name>        Runtime override: node, bun, deno",
+    "  --name, -n <name>           Process name used by list/stop/restart",
+    "  --cwd <dir>                 Working directory for the managed process",
+    "  --env KEY=VALUE             Add or override an environment variable",
+    "  --password <value>          Password for locked WAPK archives",
+    "  --sync-interval <ms>        Forward WAPK live-sync write interval (>= 50ms)",
+    "  --watcher, --use-watcher    Forward event-driven WAPK file watching",
+    "  --archive-watch             Pull archive source changes back into the temp WAPK workdir",
+    "  --no-archive-watch          Disable archive-source read sync for WAPK apps",
+    "  --archive-sync-interval <ms>  Forward WAPK archive read-sync interval (>= 50ms)",
+    "  --restart-policy <mode>     Restart policy: always, on-failure, never",
+    "  --min-uptime <ms>           Reset crash counter after this healthy uptime",
+    "  --watch                     Restart when watched files change",
+    "  --watch-path <path>         Add a file or directory to watch",
+    "  --watch-ignore <pattern>    Ignore watched paths matching this glob-like pattern",
+    "  --watch-debounce <ms>       Debounce file-triggered restarts (default 250)",
+    "  --health-url <url>          Poll an HTTP endpoint and restart after repeated failures",
+    "  --health-grace-period <ms>  Delay before the first health check (default 5000)",
+    "  --health-interval <ms>      Health check interval (default 10000)",
+    "  --health-timeout <ms>       Per-request health check timeout (default 3000)",
+    "  --health-max-failures <n>   Consecutive failures before restart (default 3)",
+    "  --no-autorestart            Disable automatic restart",
+    "  --restart-delay <ms>        Delay between restart attempts (default 1000)",
+    "  --max-restarts <count>      Maximum restart attempts (default 10)",
+    "",
+    "Config:",
+    "  Add pm.apps[] to elit.config.* and run elit pm start to boot all configured apps.",
+    "",
+    "Example:",
+    "  export default {",
+    "    pm: {",
+    "      apps: [",
+    '        { name: "api", script: "npm start", cwd: ".", runtime: "node" },',
+    '        { name: "worker", file: "./src/worker.ts", runtime: "bun" },',
+    '        { name: "desktop-app", wapk: "./dist/app.wapk", runtime: "node" },',
+    '        { name: "drive-app", wapkRun: { googleDrive: { fileId: "1AbCdEfGhIjKlMnOp", accessTokenEnv: "GOOGLE_DRIVE_ACCESS_TOKEN" }, useWatcher: true, watchArchive: true } }',
+    "      ]",
+    "    }",
+    "  }",
+    "",
+    "Notes:",
+    "  - PM state and logs are stored in ./.elit/pm by default.",
+    "  - elit pm save persists running apps to pm.dumpFile or ./.elit/pm/dump.json.",
+    "  - elit pm resurrect restarts whatever was last saved by elit pm save.",
+    "  - elit pm start <name> starts a configured app by name.",
+    "  - TypeScript files with runtime node require tsx, otherwise use --runtime bun.",
+    "  - WAPK processes are executed through elit wapk run inside the manager.",
+    "  - WAPK PM apps can use local archives, gdrive://<fileId>, or pm.apps[].wapkRun.googleDrive."
+  ].join("\n"));
+}
+async function runPmCommand(args) {
+  if (args.length === 0 || args[0] === "help" || args.includes("--help") || args.includes("-h")) {
+    printPmHelp();
+    return;
+  }
+  const command = args[0];
+  switch (command) {
+    case "start":
+      await runPmStart(args.slice(1));
+      return;
+    case "list":
+    case "ls": {
+      const { paths } = await loadPmContext();
+      printPmList(paths);
+      return;
+    }
+    case "stop":
+      await runPmStop(args.slice(1));
+      return;
+    case "restart":
+      await runPmRestart(args.slice(1));
+      return;
+    case "delete":
+    case "remove":
+    case "rm":
+      await runPmDelete(args.slice(1));
+      return;
+    case "save":
+      await runPmSave();
+      return;
+    case "resurrect":
+      await runPmResurrect();
+      return;
+    case "logs":
+      await runPmLogs(args.slice(1));
+      return;
+    case "__run":
+      await runPmRunner(args.slice(1));
+      return;
+    default:
+      throw new Error(`Unknown pm command: ${command}`);
+  }
+}
+
 // src/cli.ts
-var COMMANDS = ["dev", "build", "preview", "test", "desktop", "mobile", "native", "wapk", "help", "version"];
+var COMMANDS = ["dev", "build", "preview", "test", "desktop", "mobile", "native", "pm", "wapk", "help", "version"];
 function setupShutdownHandlers(closeFunc) {
   const shutdown = async () => {
     console.log("\n[Server] Shutting down...");
@@ -78629,6 +80952,9 @@ async function main() {
     case "native":
       await runNative(args.slice(1));
       break;
+    case "pm":
+      await runPm(args.slice(1));
+      break;
     case "wapk":
       await runWapk(args.slice(1));
       break;
@@ -78849,6 +81175,14 @@ async function runWapk(args) {
     process.exit(1);
   }
 }
+async function runPm(args) {
+  try {
+    await runPmCommand(args);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
 function parseTestArgs(args) {
   const options = {};
   for (let i = 0; i < args.length; i++) {
@@ -79046,6 +81380,7 @@ Commands:
   desktop   Run or build a native desktop app
   mobile    Run native mobile workflow commands
   native    Generate native target code from an Elit entry
+  pm        Manage background processes and packaged apps
   wapk      Pack, inspect, extract, or run a .wapk app
   version   Show version number
   help      Show this help message
@@ -79092,18 +81427,38 @@ Native Options:
   elit native generate ... --export <name>  Select a specific module export
 
 WAPK Options:
-  elit wapk <file.wapk>                     Run a packaged app
-  elit wapk run <file.wapk>                 Run a packaged app
+  elit wapk [file.wapk]                     Run a packaged app or the configured default archive
+  elit wapk gdrive://<fileId>               Run a packaged app directly from Google Drive
+  elit wapk run [file.wapk]                 Run a packaged app or the configured default archive
+  elit wapk run --google-drive-file-id <id> Run a packaged app directly from Google Drive
   elit wapk pack [directory]                Pack a directory into a .wapk archive
   elit wapk inspect <file.wapk>             Inspect a .wapk archive
   elit wapk extract <file.wapk>             Extract a .wapk archive
-  elit wapk --runtime node|bun|deno <file>  Override the packaged runtime
+  elit wapk --runtime node|bun|deno [file]  Override the packaged runtime
+
+PM Options:
+  elit pm start --script "npm start" -n my-app   Start a shell command in the background
+  elit pm start ./app.ts -n my-app               Start a file with inferred runtime
+  elit pm start --wapk ./app.wapk -n my-app      Start a WAPK app through the manager
+  elit pm start --wapk gdrive://<fileId> -n my-app  Start a Google Drive WAPK app through the manager
+  elit pm start --google-drive-file-id <id> -n my-app  Start a Google Drive WAPK app without a positional source
+  elit pm start my-app --watch                   Start one configured app with file watching enabled
+  elit pm start                                   Start all pm.apps[] entries from elit.config.*
+  elit pm start my-app                            Start one configured app by name
+  elit pm list                                    Show managed process status
+  elit pm stop <name|all>                         Stop one or all managed processes
+  elit pm restart <name|all>                      Restart one or all managed processes
+  elit pm delete <name|all>                       Remove process metadata and logs
+  elit pm save                                    Persist the running process list to pm.dumpFile
+  elit pm resurrect                               Restart the last saved process list
+  elit pm logs <name> --lines 100                 Show recent stdout/stderr logs
 
 Note: Build configuration supports both single and multiple builds:
       - Single build: build: { entry: 'src/app.ts', outDir: 'dist' }
       - Multiple builds: build: [{ entry: 'src/app1.ts' }, { entry: 'src/app2.ts' }]
       When using array, all builds run sequentially.
   Desktop commands can read desktop.entry or desktop.native.entry from elit.config.ts when [entry] is omitted, depending on desktop.mode.
+  PM commands read pm.apps[], pm.dataDir, and pm.dumpFile from elit.config.* when present.
 
 Preview Options:
   -p, --port <number>      Port to run server on (default: 4173)
@@ -79419,6 +81774,7 @@ main().catch((error) => {
   runDev,
   runMobile,
   runNative,
+  runPm,
   runPreview,
   runTest,
   runWapk