elit 3.6.4 → 3.6.5

package/Cargo.lock

@@ -1211,7 +1211,7 @@ dependencies = [
 
 [[package]]
 name = "elit-desktop"
-version = "3.6.4"
+version = "3.6.5"
 dependencies = [
  "eframe",
  "http",

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "elit-desktop"
-version = "3.6.4"
+version = "3.6.5"
 edition = "2021"
 build = "desktop/build.rs"
 

package/README.md

@@ -866,6 +866,9 @@ createWindow({
 });
 ```
 
+For a runnable minimal file in this repo, see `examples/desktop-simple-example.ts`.
+For a runnable project-style repo, see `examples/desktop-typescript-example/`.
+
 Run it:
 
 ```bash
@@ -955,7 +958,7 @@ The package also exports `elit/test`, `elit/test-runtime`, and `elit/test-report
 
 Latest release notes live in [CHANGELOG.md](CHANGELOG.md).
 
-Highlights in `v3.6.4`:
+Highlights in `v3.6.5`:
 
 - Added `elit pm` for detached background process management of shell commands, file targets, and WAPK apps.
 - Added `pm.apps[]` and `pm.dataDir` in `elit.config.*` for config-first process manager workflows.
@@ -992,6 +995,8 @@ If you are working in this repository, these locations matter most:
 - `examples/full-db`: larger full-stack example with database usage
 - `examples/universal-app-example`: one repo covering web, desktop, and Android mobile smoke flows
 - `examples/android-native-example`: Android-first native mobile validation flow
+- `examples/desktop-typescript-example`: project-style desktop app with `package.json`, `elit.config.ts`, and a TypeScript desktop entry
+- `examples/desktop-simple-example.ts`: minimal desktop window example with inline HTML + IPC buttons
 - `examples/desktop-example.ts`: desktop smoke test and runtime example
 - `packages/create-elit`: scaffold templates used by `npm create elit@latest`
 - `docs/`: the documentation site built with Elit itself
@@ -1008,6 +1013,8 @@ If you are working in this repository, these locations matter most:
 - `examples/correct-config` for the cleanest SSR + API setup
 - `examples/universal-app-example` for a single repo exercising web, desktop, and Android mobile together
 - `examples/android-native-example` for Android-native mobile validation
+- `examples/desktop-typescript-example` for a small desktop project you can install and run directly
+- `examples/desktop-simple-example.ts` for the smallest desktop window example
 - `examples/desktop-example.ts` for desktop runtime usage
 - `USAGE_EXAMPLES.md` for more import combinations
 - `docs/API.md` for broader API detail

package/dist/cli.cjs

@@ -1992,8 +1992,8 @@ var require_chance = __commonJS({
           return i;
         });
       }
-      function testRange(test2, errorMessage) {
-        if (test2) {
+      function testRange(test, errorMessage) {
+        if (test) {
           throw new RangeError(errorMessage);
         }
       }
@@ -54898,12 +54898,126 @@ ${k.ValidationErrorsFormatter.format(i2)}`);
 });
 
 // src/test-runtime.ts
-function escapeRegex(str) {
+function escapeRegex2(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+function resolveTestLoader(filePath) {
+  return /\.(?:ts|tsx|mts|cts)$/i.test(filePath) ? "ts" : "js";
+}
+function createTestTransformOptions(filePath, format2, sourcemap) {
+  return {
+    loader: resolveTestLoader(filePath),
+    format: format2,
+    sourcemap,
+    sourcefile: filePath,
+    target: "es2020",
+    tsconfigRaw: {
+      compilerOptions: {
+        jsx: "react",
+        jsxFactory: "h",
+        jsxFragmentFactory: "Fragment"
+      }
+    }
+  };
+}
+function resolveExistingTestModulePath(basePath) {
+  const nodePath = require("path");
+  if (existsSync(basePath) && statSync(basePath).isFile()) {
+    return basePath;
+  }
+  for (const extension of TEST_MODULE_EXTENSIONS) {
+    const candidatePath = `${basePath}${extension}`;
+    if (existsSync(candidatePath) && statSync(candidatePath).isFile()) {
+      return candidatePath;
+    }
+  }
+  if (existsSync(basePath) && statSync(basePath).isDirectory()) {
+    const packageJsonPath = nodePath.join(basePath, "package.json");
+    if (existsSync(packageJsonPath) && statSync(packageJsonPath).isFile()) {
+      try {
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+        for (const candidateEntry of [packageJson.main, packageJson.module]) {
+          if (typeof candidateEntry !== "string" || candidateEntry.trim().length === 0) {
+            continue;
+          }
+          try {
+            return resolveExistingTestModulePath(nodePath.resolve(basePath, candidateEntry));
+          } catch {
+            continue;
+          }
+        }
+      } catch {
+      }
+    }
+    for (const extension of TEST_MODULE_EXTENSIONS) {
+      const candidatePath = nodePath.join(basePath, `index${extension}`);
+      if (existsSync(candidatePath) && statSync(candidatePath).isFile()) {
+        return candidatePath;
+      }
+    }
+  }
+  return basePath;
+}
+function resolveTestModulePath(fromFilePath, specifier) {
+  if (!specifier.startsWith(".") && !specifier.startsWith("/")) {
+    return specifier;
+  }
+  const nodePath = require("path");
+  const basePath = specifier.startsWith(".") ? nodePath.resolve(dirname(fromFilePath), specifier) : specifier;
+  return resolveExistingTestModulePath(basePath);
+}
+function shouldTranspileTestModule(filePath) {
+  return /\.(?:ts|tsx|mts|cts|js|jsx|mjs|cjs)$/i.test(filePath);
+}
+function createTestModuleRequire(fromFilePath, moduleCache) {
+  return (specifier) => {
+    if (specifier.startsWith("elit/") || specifier === "elit") {
+      return require(specifier);
+    }
+    const resolvedPath = resolveTestModulePath(fromFilePath, specifier);
+    if (resolvedPath === specifier) {
+      return require(specifier);
+    }
+    if (!existsSync(resolvedPath) || !statSync(resolvedPath).isFile()) {
+      return require(resolvedPath);
+    }
+    if (!shouldTranspileTestModule(resolvedPath)) {
+      return require(resolvedPath);
+    }
+    return loadTranspiledTestModule(resolvedPath, moduleCache);
+  };
+}
+function loadTranspiledTestModule(modulePath, moduleCache) {
+  const cached = moduleCache.get(modulePath);
+  if (cached) {
+    return cached.exports;
+  }
+  const source = readFileSync(modulePath, "utf-8");
+  let transpiled;
+  try {
+    transpiled = (0, import_esbuild3.transformSync)(source, createTestTransformOptions(modulePath, "cjs", false));
+  } catch (error) {
+    throw new Error(`Failed to transpile test dependency ${modulePath}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const moduleRecord = { exports: {} };
+  const moduleObj = { exports: moduleRecord.exports };
+  moduleCache.set(modulePath, moduleRecord);
+  try {
+    const fn = new Function("module", "exports", "require", "__filename", "__dirname", transpiled.code);
+    const requireFn = createTestModuleRequire(modulePath, moduleCache);
+    fn(moduleObj, moduleObj.exports, requireFn, modulePath, dirname(modulePath));
+  } catch (error) {
+    throw new Error(`Failed to execute test dependency ${modulePath}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  moduleRecord.exports = moduleObj.exports;
+  if (!modulePath.includes(".test.") && !modulePath.includes(".spec.")) {
+    coveredFiles.add(modulePath);
+  }
+  return moduleRecord.exports;
+}
 function createTestFunction(defaultTimeout = 5e3) {
   const testFn = function(name, fn, timeout) {
-    const test2 = {
+    const test = {
       name,
       fn,
       skip: currentSuite.skip,
@@ -54912,10 +55026,10 @@ function createTestFunction(defaultTimeout = 5e3) {
       timeout: timeout ?? defaultTimeout,
       suite: currentSuite
     };
-    currentSuite.tests.push(test2);
+    currentSuite.tests.push(test);
   };
   testFn.skip = (name, fn, timeout) => {
-    const test2 = {
+    const test = {
       name,
       fn,
       skip: true,
@@ -54924,11 +55038,11 @@ function createTestFunction(defaultTimeout = 5e3) {
       timeout: timeout ?? defaultTimeout,
       suite: currentSuite
     };
-    currentSuite.tests.push(test2);
+    currentSuite.tests.push(test);
   };
   testFn.only = (name, fn, timeout) => {
     hasOnly = true;
-    const test2 = {
+    const test = {
       name,
       fn,
       skip: false,
@@ -54937,10 +55051,10 @@ function createTestFunction(defaultTimeout = 5e3) {
       timeout: timeout ?? defaultTimeout,
       suite: currentSuite
     };
-    currentSuite.tests.push(test2);
+    currentSuite.tests.push(test);
   };
   testFn.todo = (name, fn, timeout) => {
-    const test2 = {
+    const test = {
       name,
       fn,
       skip: false,
@@ -54949,7 +55063,7 @@ function createTestFunction(defaultTimeout = 5e3) {
       timeout: timeout ?? defaultTimeout,
       suite: currentSuite
     };
-    currentSuite.tests.push(test2);
+    currentSuite.tests.push(test);
   };
   return testFn;
 }
@@ -55059,29 +55173,7 @@ async function runTests(options) {
     try {
       const source = await readFile(file, "utf-8");
       const testFileDir = dirname(file);
-      const importRegex = /import\s+{\s*([^}]+)\s*}\s+from\s+['"]([^'"]+)['"]/g;
-      const imports = {};
-      let importIndex = 0;
-      let codeWithoutImports = source.replace(importRegex, (_, named, path) => {
-        const varName = `__import_${importIndex++}`;
-        const trimmedNamed = named.trim();
-        imports[varName] = { path, named: trimmedNamed };
-        return `// ${trimmedNamed} import injected later
-`;
-      });
-      const result2 = (0, import_esbuild3.transformSync)(codeWithoutImports, {
-        loader: file.endsWith(".ts") || file.endsWith(".tsx") ? "ts" : "js",
-        format: "iife",
-        sourcemap: "inline",
-        target: "es2020",
-        tsconfigRaw: {
-          compilerOptions: {
-            jsx: "react",
-            jsxFactory: "h",
-            jsxFragmentFactory: "Fragment"
-          }
-        }
-      });
+      const result2 = (0, import_esbuild3.transformSync)(source, createTestTransformOptions(file, "cjs", "inline"));
       let code = result2.code;
       const sourceMapMatch = code.match(/\/\/# sourceMappingURL=data:application\/json;base64,(.+)/);
       if (sourceMapMatch) {
@@ -55092,99 +55184,15 @@ async function runTests(options) {
       } else {
         currentSourceMapConsumer = void 0;
       }
-      const importedValues = {};
-      const importParamNames = [];
-      const importAssignments = [];
-      if (Object.keys(imports).length > 0) {
-        for (const [, { path, named }] of Object.entries(imports)) {
-          let resolvedPath = path;
-          if (path.startsWith(".")) {
-            const nodePath = require("path");
-            resolvedPath = nodePath.resolve(testFileDir, path);
-          }
-          if (!resolvedPath.endsWith(".ts") && !resolvedPath.endsWith(".js") && !resolvedPath.endsWith(".mjs") && !resolvedPath.endsWith(".cjs")) {
-            resolvedPath += ".ts";
-          }
-          if (resolvedPath.endsWith(".ts")) {
-            try {
-              const importSource = await readFile(resolvedPath, "utf-8");
-              const transpiled = (0, import_esbuild3.transformSync)(importSource, {
-                loader: "ts",
-                format: "cjs",
-                target: "es2020",
-                tsconfigRaw: {
-                  compilerOptions: {
-                    jsx: "react",
-                    jsxFactory: "h",
-                    jsxFragmentFactory: "Fragment"
-                  }
-                }
-              });
-              const moduleExports = {};
-              const moduleObj = { exports: moduleExports };
-              const fn2 = new Function("module", "exports", "require", "__filename", "__dirname", transpiled.code);
-              const requireFn = (id) => {
-                if (id.startsWith("elit/") || id === "elit") {
-                  return require(id);
-                }
-                if (id.startsWith(".")) {
-                  const nodePath = require("path");
-                  const absPath = nodePath.resolve(dirname(resolvedPath), id);
-                  return require(absPath);
-                }
-                return require(id);
-              };
-              fn2(moduleObj, moduleExports, requireFn, resolvedPath, dirname(resolvedPath));
-              if (!resolvedPath.includes(".test.") && !resolvedPath.includes(".spec.")) {
-                coveredFiles.add(resolvedPath);
-              }
-              let exportedValue = moduleObj.exports[named];
-              if (exportedValue === void 0 && moduleObj.exports.default) {
-                exportedValue = moduleObj.exports.default[named];
-              }
-              if (exportedValue === void 0 && typeof moduleObj.exports === "object") {
-                exportedValue = moduleObj.exports[named];
-              }
-              const paramKey = `__import_${Math.random().toString(36).substring(2, 11)}`;
-              importedValues[paramKey] = exportedValue;
-              importParamNames.push(paramKey);
-              importAssignments.push(`const ${named} = ${paramKey};`);
-            } catch (err) {
-              const paramKey = `__import_${Math.random().toString(36).substring(2, 11)}`;
-              importedValues[paramKey] = null;
-              importParamNames.push(paramKey);
-              importAssignments.push(`const ${named} = ${paramKey}; /* Error importing ${resolvedPath}: ${err} */`);
-            }
-          } else {
-            const requiredModule = require(resolvedPath);
-            const exportedValue = requiredModule[named];
-            const paramKey = `__import_${Math.random().toString(36).substring(2, 11)}`;
-            importedValues[paramKey] = exportedValue;
-            importParamNames.push(paramKey);
-            importAssignments.push(`const ${named} = ${paramKey};`);
-          }
-        }
-      }
-      let preamble = "";
-      if (Object.keys(imports).length > 0) {
-        const iifeStartMatch = code.match(/^(\s*(?:var\s+\w+\s*=\s*)?\(\(\)\s*=>\s*\{\n)/);
-        if (iifeStartMatch) {
-          const iifePrefix = iifeStartMatch[1];
-          const assignments = `${importAssignments.join("\n")}
-`;
-          preamble = iifePrefix;
-          code = iifePrefix + assignments + code.slice(iifeStartMatch[1].length);
-        } else {
-          preamble = importAssignments.join("\n") + "\n";
-          code = preamble + code;
-        }
-      }
-      wrapperLineOffset = preamble.split("\n").length;
+      wrapperLineOffset = 0;
       setupGlobals();
-      const allParams = ["describe", "it", "test", "expect", "beforeAll", "afterAll", "beforeEach", "afterEach", "vi", "require", "module", "__filename", "__dirname", ...importParamNames];
-      const allArgs = [describe, it, test, expect, beforeAll, afterAll, beforeEach, afterEach, vi, require, module, file, testFileDir, ...importParamNames.map((p) => importedValues[p])];
-      const fn = new Function(...allParams, code);
-      await fn(...allArgs);
+      const moduleCache = /* @__PURE__ */ new Map();
+      const moduleRecord = { exports: {} };
+      const moduleObj = { exports: moduleRecord.exports };
+      moduleCache.set(file, moduleRecord);
+      const fn = new Function("module", "exports", "require", "__filename", "__dirname", code);
+      const requireFn = createTestModuleRequire(file, moduleCache);
+      await fn(moduleObj, moduleObj.exports, requireFn, file, testFileDir);
       await executeSuite(currentSuite, timeout, bail);
       if (currentSourceMapConsumer) {
         currentSourceMapConsumer.destroy();
@@ -55219,13 +55227,13 @@ async function runTests(options) {
 async function executeSuite(suite, timeout, bail, parentMatched = false) {
   let directMatch = false;
   if (describePattern) {
-    const escapedPattern = escapeRegex(describePattern);
+    const escapedPattern = escapeRegex2(describePattern);
     const regex = new RegExp(escapedPattern, "i");
     directMatch = regex.test(suite.name);
   }
   function suiteOrDescendantMatches(s) {
     if (!describePattern) return true;
-    const escapedPattern = escapeRegex(describePattern);
+    const escapedPattern = escapeRegex2(describePattern);
     const regex = new RegExp(escapedPattern, "i");
     if (regex.test(s.name)) return true;
     for (const child of s.suites) {
@@ -55249,22 +55257,22 @@ async function executeSuite(suite, timeout, bail, parentMatched = false) {
   for (const hook of beforeAllHooks) {
     await hook();
   }
-  for (const test2 of suite.tests) {
-    if (hasOnly && !test2.only && !suite.only) {
+  for (const test of suite.tests) {
+    if (hasOnly && !test.only && !suite.only) {
       continue;
     }
     let testMatches = true;
     if (testPattern) {
-      const escapedPattern = escapeRegex(testPattern);
+      const escapedPattern = escapeRegex2(testPattern);
       const regex = new RegExp(escapedPattern, "i");
-      testMatches = regex.test(test2.name);
+      testMatches = regex.test(test.name);
     }
     if (!testMatches) {
       continue;
     }
-    if (test2.skip || suite.skip) {
+    if (test.skip || suite.skip) {
       testResults.push({
-        name: test2.name,
+        name: test.name,
         status: "skip",
         duration: 0,
         suite: suite.name,
@@ -55272,9 +55280,9 @@ async function executeSuite(suite, timeout, bail, parentMatched = false) {
       });
       continue;
     }
-    if (test2.todo) {
+    if (test.todo) {
       testResults.push({
-        name: test2.name,
+        name: test.name,
         status: "todo",
         duration: 0,
         suite: suite.name,
@@ -55288,13 +55296,13 @@ async function executeSuite(suite, timeout, bail, parentMatched = false) {
     const startTime = Date.now();
     try {
       await Promise.race([
-        test2.fn(),
+        test.fn(),
         new Promise(
-          (_, reject) => setTimeout(() => reject(new Error(`Test timed out after ${test2.timeout}ms`)), test2.timeout)
+          (_, reject) => setTimeout(() => reject(new Error(`Test timed out after ${test.timeout}ms`)), test.timeout)
         )
       ]);
       testResults.push({
-        name: test2.name,
+        name: test.name,
         status: "pass",
         duration: Date.now() - startTime,
         suite: suite.name,
@@ -55308,7 +55316,7 @@ async function executeSuite(suite, timeout, bail, parentMatched = false) {
         codeSnippet = error.codeSnippet;
       }
       testResults.push({
-        name: test2.name,
+        name: test.name,
         status: "fail",
         duration: Date.now() - startTime,
         error,
@@ -55357,7 +55365,7 @@ function getCoveredFiles() {
 function resetCoveredFiles() {
   coveredFiles.clear();
 }
-var import_esbuild3, import_source_map, AssertionError, currentSuite, testResults, hasOnly, coveredFiles, describePattern, testPattern, currentTestFile, currentSourceMapConsumer, wrapperLineOffset, Expect, vi, beforeAllHooks, afterAllHooks, beforeEachHooks, afterEachHooks, beforeAll, afterAll, beforeEach, afterEach, globals;
+var import_esbuild3, import_source_map, AssertionError, currentSuite, testResults, hasOnly, coveredFiles, describePattern, testPattern, currentTestFile, currentSourceMapConsumer, wrapperLineOffset, TEST_MODULE_EXTENSIONS, Expect, vi, beforeAllHooks, afterAllHooks, beforeEachHooks, afterEachHooks, beforeAll, afterAll, beforeEach, afterEach, globals;
 var init_test_runtime = __esm({
   "src/test-runtime.ts"() {
     "use strict";
@@ -55390,6 +55398,7 @@ var init_test_runtime = __esm({
     currentTestFile = void 0;
     currentSourceMapConsumer = void 0;
     wrapperLineOffset = 0;
+    TEST_MODULE_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs", ".json"];
     Expect = class _Expect {
       constructor(actual, isNot = false, isAsync = false) {
         this.actual = actual;
@@ -74875,7 +74884,7 @@ function readLineIgnorePatterns(filePath) {
   if (!(0, import_node_fs2.existsSync)(filePath)) {
     return [];
   }
-  return (0, import_node_fs2.readFileSync)(filePath, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+  return (0, import_node_fs2.readFileSync)(filePath, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && (!line.startsWith("#") || line.startsWith("\\#")));
 }
 function normalizePackageEntry(value) {
   const normalized = normalizeNonEmptyString(value)?.replace(/^[.][\\/]/, "").split("\\").join("/");
@@ -75056,23 +75065,103 @@ function resolveLinkedDependencyArchivePrefix(archivePrefix, dependencyName) {
   }
   return `${normalizedPrefix.slice(0, markerIndex + marker.length)}${dependencyName}`;
 }
-function shouldIgnore(relativePath2, ignorePatterns) {
-  const pathParts = relativePath2.split("/");
-  for (const pattern of ignorePatterns) {
-    if (relativePath2 === pattern || pathParts.includes(pattern)) {
-      return true;
-    }
-    if (pattern.endsWith("*")) {
-      const prefix = pattern.slice(0, -1);
-      if (relativePath2.startsWith(prefix) || pathParts.some((part) => part.startsWith(prefix))) {
-        return true;
+function escapeRegex(text) {
+  return text.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+}
+function globPatternToRegex(pattern, options = {}) {
+  let regex = "";
+  for (let index = 0; index < pattern.length; index++) {
+    const char = pattern[index];
+    if (char === "*") {
+      const nextChar = pattern[index + 1];
+      const nextNextChar = pattern[index + 2];
+      if (nextChar === "*") {
+        if (nextNextChar === "/") {
+          regex += "(?:.*?/)?";
+          index += 2;
+          continue;
+        }
+        regex += ".*";
+        index += 1;
+        continue;
       }
+      regex += "[^/]*";
+      continue;
     }
-    if (pattern.startsWith("*.") && relativePath2.endsWith(pattern.slice(1))) {
-      return true;
+    if (char === "?") {
+      regex += "[^/]";
+      continue;
     }
+    regex += escapeRegex(char);
   }
-  return false;
+  const suffix = options.directoryOnly ? "(?:$|/.*)" : "$";
+  const prefix = options.matchSegmentsOnly ? "^(?:.*?/)?" : "^";
+  return new RegExp(`${prefix}${regex}${suffix}`);
+}
+function normalizeIgnorePattern(pattern) {
+  let normalizedPattern = pattern.trim();
+  if (!normalizedPattern) {
+    return void 0;
+  }
+  let negate = false;
+  if (normalizedPattern.startsWith("\\!") || normalizedPattern.startsWith("\\#")) {
+    normalizedPattern = normalizedPattern.slice(1);
+  } else if (normalizedPattern.startsWith("!")) {
+    negate = true;
+    normalizedPattern = normalizedPattern.slice(1).trim();
+  }
+  if (!normalizedPattern) {
+    return void 0;
+  }
+  const directoryOnly = normalizedPattern.endsWith("/");
+  if (directoryOnly) {
+    normalizedPattern = normalizedPattern.replace(/\/+$/, "");
+  }
+  normalizedPattern = normalizedPattern.replace(/^\.\//, "").replace(/^\//, "").replace(/\\/g, "/");
+  if (!normalizedPattern) {
+    return void 0;
+  }
+  return {
+    directoryOnly,
+    matchSegmentsOnly: !normalizedPattern.includes("/"),
+    negate,
+    pattern: normalizedPattern
+  };
+}
+function matchesIgnorePattern(relativePath2, pattern, isDirectory) {
+  const normalizedRule = normalizeIgnorePattern(pattern);
+  if (!normalizedRule) {
+    return false;
+  }
+  if (normalizedRule.directoryOnly && !isDirectory) {
+    return false;
+  }
+  const hasGlob = /[*?]/.test(normalizedRule.pattern);
+  if (!hasGlob) {
+    if (normalizedRule.matchSegmentsOnly) {
+      return relativePath2 === normalizedRule.pattern || relativePath2.split("/").includes(normalizedRule.pattern);
+    }
+    return relativePath2 === normalizedRule.pattern;
+  }
+  if (normalizedRule.matchSegmentsOnly) {
+    const segmentRegex = globPatternToRegex(normalizedRule.pattern);
+    return relativePath2.split("/").some((segment) => segmentRegex.test(segment));
+  }
+  return globPatternToRegex(normalizedRule.pattern, { directoryOnly: normalizedRule.directoryOnly }).test(relativePath2);
+}
+function shouldIgnore(relativePath2, ignorePatterns, isDirectory) {
+  let ignored = false;
+  for (const pattern of ignorePatterns) {
+    const normalizedRule = normalizeIgnorePattern(pattern);
+    if (!normalizedRule) {
+      continue;
+    }
+    if (!matchesIgnorePattern(relativePath2, pattern, isDirectory)) {
+      continue;
+    }
+    ignored = !normalizedRule.negate;
+  }
+  return ignored;
 }
 function collectFiles(directory, baseDirectory, ignorePatterns) {
   const files = [];
@@ -75080,7 +75169,7 @@ function collectFiles(directory, baseDirectory, ignorePatterns) {
   for (const entry of entries) {
     const fullPath = (0, import_node_path2.join)(directory, entry.name);
     const relativePath2 = (0, import_node_path2.relative)(baseDirectory, fullPath).split("\\").join("/");
-    if (shouldIgnore(relativePath2, ignorePatterns)) {
+    if (shouldIgnore(relativePath2, ignorePatterns, entry.isDirectory())) {
       continue;
     }
     if (entry.isSymbolicLink()) {
@@ -76483,7 +76572,7 @@ function printWapkHelp() {
     "",
     "Notes:",
     "  - Pack reads wapk from elit.config.* and falls back to package.json.",
-    "  - Pack includes node_modules by default; use .wapkignore if you need to exclude them.",
+    "  - Pack includes node_modules by default; use .wapkignore if you need to exclude them, and !pattern to re-include later matches.",
     "  - Run never installs dependencies automatically; archives must include the runtime dependencies they need.",
     "  - Run mode can read config.wapk.run for default file/runtime/live-sync options.",
     "  - Browser-style archives with scripts.start or wapk.script.start run that start script automatically.",