elit 3.6.4 → 3.6.6

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;
@@ -60475,6 +60484,71 @@ function lookup(path) {
 // src/server.ts
 init_runtime();
 
+// src/smtp-server.ts
+var import_smtp_server = require("smtp-server");
+var DEFAULT_SMTP_PORT = 2525;
+var DEFAULT_SMTP_HOST = "127.0.0.1";
+function resolveSmtpServerConfig(config = {}) {
+  const { port = DEFAULT_SMTP_PORT, host = DEFAULT_SMTP_HOST, label, ...serverOptions } = config;
+  return {
+    ...serverOptions,
+    port,
+    host,
+    label
+  };
+}
+function normalizeSmtpServerConfigs(input) {
+  const configs = Array.isArray(input) ? input : input ? [input] : [];
+  return configs.map((config) => resolveSmtpServerConfig(config));
+}
+function closeSmtpServer(server) {
+  return new Promise((resolve9, reject) => {
+    let settled = false;
+    const finish = (error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve9();
+    };
+    const handleCloseError = (error) => {
+      const errorCode = error.code;
+      if (errorCode === "ERR_SERVER_NOT_RUNNING") {
+        finish();
+        return;
+      }
+      finish(error);
+    };
+    try {
+      server.close(() => finish());
+    } catch (error) {
+      handleCloseError(error);
+    }
+  });
+}
+function createSmtpServer(config = {}) {
+  const resolvedConfig = resolveSmtpServerConfig(config);
+  const { port, host, label: _label, ...serverOptions } = resolvedConfig;
+  const server = new import_smtp_server.SMTPServer(serverOptions);
+  return {
+    server,
+    config: resolvedConfig,
+    listen(callback) {
+      return callback ? server.listen(port, host, callback) : server.listen(port, host);
+    },
+    address() {
+      return server.server.address();
+    },
+    close() {
+      return closeSmtpServer(server);
+    }
+  };
+}
+
 // src/render-context.ts
 var RUNTIME_TARGET_KEY = "__ELIT_RUNTIME_TARGET__";
 var CAPTURED_RENDER_KEY = "__ELIT_CAPTURED_RENDER__";
@@ -60928,6 +61002,7 @@ var DomNode = class {
       html += `</${tagName}>${newLine}`;
       return html;
     }
+    const isRawText = tagName === "script" || tagName === "style";
     if (children && children.length > 0) {
       const resolvedChildren = children.map((c) => {
         const resolved = this.resolveStateValue(c);
@@ -60943,11 +61018,11 @@ var DomNode = class {
           if (Array.isArray(child)) {
             for (const c of child) {
               if (!shouldSkipChild(c)) {
-                html += this.renderToString(c, { pretty, indent: indent5 + 1 });
+                html += isRawText && typeof c === "string" ? c : this.renderToString(c, { pretty, indent: indent5 + 1 });
               }
             }
           } else {
-            html += this.renderToString(child, { pretty, indent: indent5 + 1 });
+            html += isRawText && typeof child === "string" ? child : this.renderToString(child, { pretty, indent: indent5 + 1 });
           }
         }
         html += indentStr;
@@ -60957,11 +61032,11 @@ var DomNode = class {
           if (Array.isArray(child)) {
             for (const c of child) {
               if (!shouldSkipChild(c)) {
-                html += this.renderToString(c, { pretty: false, indent: 0 });
+                html += isRawText && typeof c === "string" ? c : this.renderToString(c, { pretty: false, indent: 0 });
               }
             }
           } else {
-            html += this.renderToString(child, { pretty: false, indent: 0 });
+            html += isRawText && typeof child === "string" ? child : this.renderToString(child, { pretty: false, indent: 0 });
           }
         }
       }
@@ -61889,6 +61964,56 @@ var defaultOptions = {
   worker: [],
   mode: "dev"
 };
+function createSmtpBindingKey(config) {
+  return `${config.host}:${config.port}`;
+}
+function createSmtpServerLabel(config) {
+  return config.label || createSmtpBindingKey(config);
+}
+function formatSmtpServerAddress(address, fallback) {
+  if (typeof address === "string") {
+    return address;
+  }
+  if (address) {
+    return `${address.address}:${address.port}`;
+  }
+  return createSmtpBindingKey(fallback);
+}
+function collectSmtpServerConfigs(config, usesClientArray) {
+  const modeLabel = config.mode || "dev";
+  const smtpConfigs = normalizeSmtpServerConfigs(config.smtp).map((smtpConfig, index) => ({
+    ...smtpConfig,
+    label: smtpConfig.label || `${modeLabel}.smtp[${index}]`
+  }));
+  if (!usesClientArray || !config.clients) {
+    return smtpConfigs;
+  }
+  for (let clientIndex = 0; clientIndex < config.clients.length; clientIndex += 1) {
+    const client = config.clients[clientIndex];
+    const clientDescriptor = client.basePath || client.root;
+    const clientPrefix = clientDescriptor ? `${modeLabel}.clients[${clientIndex}] (${clientDescriptor})` : `${modeLabel}.clients[${clientIndex}]`;
+    smtpConfigs.push(...normalizeSmtpServerConfigs(client.smtp).map((smtpConfig, smtpIndex) => ({
+      ...smtpConfig,
+      label: smtpConfig.label || `${clientPrefix}.smtp[${smtpIndex}]`
+    })));
+  }
+  return smtpConfigs;
+}
+function assertUniqueSmtpServerBindings(configs) {
+  const seenBindings = /* @__PURE__ */ new Map();
+  for (const smtpConfig of configs) {
+    if (smtpConfig.port === 0) {
+      continue;
+    }
+    const bindingKey = createSmtpBindingKey(smtpConfig);
+    const currentLabel = createSmtpServerLabel(smtpConfig);
+    const previousLabel = seenBindings.get(bindingKey);
+    if (previousLabel) {
+      throw new Error(`Duplicate SMTP server binding "${bindingKey}" configured for ${previousLabel} and ${currentLabel}`);
+    }
+    seenBindings.set(bindingKey, currentLabel);
+  }
+}
 function shouldUseClientFallbackRoot(primaryRoot, fallbackRoot, indexPath) {
   if (!fallbackRoot) {
     return false;
@@ -62023,6 +62148,7 @@ function createDevServer(options) {
   const globalWebSocketEndpoints = usesClientArray ? normalizeWebSocketEndpoints(config.ws) : [];
   const normalizedWebSocketEndpoints = [...normalizedClients.flatMap((client) => client.ws), ...globalWebSocketEndpoints];
   const seenWebSocketPaths = /* @__PURE__ */ new Set();
+  const smtpServerConfigs = collectSmtpServerConfigs(config, usesClientArray);
   for (const endpoint of normalizedWebSocketEndpoints) {
     if (endpoint.path === ELIT_INTERNAL_WS_PATH) {
       throw new Error(`WebSocket path "${ELIT_INTERNAL_WS_PATH}" is reserved for Elit internals`);
@@ -62032,6 +62158,21 @@ function createDevServer(options) {
     }
     seenWebSocketPaths.add(endpoint.path);
   }
+  assertUniqueSmtpServerBindings(smtpServerConfigs);
+  const smtpServers = smtpServerConfigs.map((smtpConfig) => {
+    const smtpServer = createSmtpServer(smtpConfig);
+    const smtpLabel = createSmtpServerLabel(smtpServer.config);
+    smtpServer.server.on("error", (error) => {
+      console.error(`[SMTP] ${smtpLabel} error:`, error);
+    });
+    if (config.logging) {
+      smtpServer.server.server.once("listening", () => {
+        console.log(`[SMTP] ${smtpLabel} listening on ${formatSmtpServerAddress(smtpServer.address(), smtpServer.config)}`);
+      });
+    }
+    smtpServer.listen();
+    return smtpServer;
+  });
   const globalProxyHandler = config.proxy ? createProxyHandler(config.proxy) : null;
   const server = createServer(async (req, res) => {
     const originalUrl = req.url || "/";
@@ -62572,6 +62713,15 @@ ${elitImportMap}`;
     if (config.logging) console.log("\n[Server] Shutting down...");
     transformCache.clear();
     if (watcher) await watcher.close();
+    if (smtpServers.length > 0) {
+      await Promise.all(smtpServers.map(async (smtpServer) => {
+        try {
+          await smtpServer.close();
+        } catch (error) {
+          console.error(`[SMTP] ${createSmtpServerLabel(smtpServer.config)} close error:`, error);
+        }
+      }));
+    }
     if (webSocketServers.length > 0) {
       webSocketServers.forEach((wsServer) => wsServer.close());
       wsClients.clear();
@@ -62588,6 +62738,7 @@ ${elitImportMap}`;
   return {
     server,
     wss,
+    smtpServers,
     url: primaryUrl,
     state: stateManager,
     close
@@ -74467,7 +74618,7 @@ 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";
 var DEFAULT_WAPK_ONLINE_URL_ENV = "ELIT_WAPK_ONLINE_URL";
-var DEFAULT_WAPK_ONLINE_URLS = ["https://wapk.d-osc.com/"];
+var DEFAULT_WAPK_ONLINE_URLS = ["http://wapk.d-osc.com/"];
 var WAPK_ONLINE_CREATE_PATH = "/api/shared-session/create";
 var WAPK_ONLINE_READ_PATH = "/api/shared-session/read";
 var WAPK_ONLINE_CLOSE_PATH = "/api/shared-session/close";
@@ -74505,6 +74656,113 @@ function normalizeNonEmptyString(value) {
   const normalized = value.trim();
   return normalized.length > 0 ? normalized : void 0;
 }
+function normalizeGeneratedIdentifier(value) {
+  const normalized = value.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return normalized.length > 0 ? normalized : void 0;
+}
+function joinGeneratedIdentifier(...segments) {
+  const normalizedSegments = segments.map((segment) => segment ? normalizeGeneratedIdentifier(segment) : void 0).filter((segment) => Boolean(segment));
+  return normalizedSegments.length > 0 ? normalizedSegments.join(".") : void 0;
+}
+function parseScopedPackageName(value) {
+  const normalizedValue = normalizeNonEmptyString(value);
+  if (!normalizedValue) {
+    return {};
+  }
+  if (!normalizedValue.startsWith("@")) {
+    return {
+      packageName: normalizedValue
+    };
+  }
+  const scopeSeparatorIndex = normalizedValue.indexOf("/");
+  if (scopeSeparatorIndex === -1) {
+    return {
+      packageName: normalizedValue
+    };
+  }
+  return {
+    scope: normalizedValue.slice(1, scopeSeparatorIndex),
+    packageName: normalizedValue.slice(scopeSeparatorIndex + 1)
+  };
+}
+function readPackageAuthorMetadata(value) {
+  if (typeof value === "string") {
+    const normalizedValue = value.trim();
+    if (!normalizedValue) {
+      return {};
+    }
+    const email = normalizedValue.match(/<([^>]+)>/)?.[1];
+    const url = normalizedValue.match(/\(([^)]+)\)/)?.[1];
+    const name = normalizedValue.replace(/<[^>]+>/g, " ").replace(/\([^)]+\)/g, " ").replace(/\s+/g, " ").trim();
+    return {
+      name: normalizeNonEmptyString(name),
+      email: normalizeNonEmptyString(email),
+      url: normalizeNonEmptyString(url)
+    };
+  }
+  if (!isRecord(value)) {
+    return {};
+  }
+  return {
+    name: normalizeNonEmptyString(value.name),
+    email: normalizeNonEmptyString(value.email),
+    url: normalizeNonEmptyString(value.url)
+  };
+}
+function extractPublisherIdFromRepository(value) {
+  const repositoryUrl = typeof value === "string" ? value : isRecord(value) ? normalizeNonEmptyString(value.url) : void 0;
+  const normalizedRepositoryUrl = normalizeNonEmptyString(repositoryUrl);
+  if (!normalizedRepositoryUrl) {
+    return void 0;
+  }
+  const shorthandMatch = normalizedRepositoryUrl.match(/^(?:github|gitlab|bitbucket):([^/]+)\/.+$/i);
+  if (shorthandMatch?.[1]) {
+    return normalizeGeneratedIdentifier(shorthandMatch[1]);
+  }
+  const sshMatch = normalizedRepositoryUrl.match(/^[^@]+@[^:]+:([^/]+)\/.+$/i);
+  if (sshMatch?.[1]) {
+    return normalizeGeneratedIdentifier(sshMatch[1]);
+  }
+  try {
+    const parsed = new URL(normalizedRepositoryUrl.replace(/^git\+/, ""));
+    const firstPathSegment = parsed.pathname.replace(/\.git$/i, "").split("/").filter(Boolean)[0];
+    return normalizeGeneratedIdentifier(firstPathSegment ?? parsed.hostname.replace(/^www\./i, ""));
+  } catch {
+    return void 0;
+  }
+}
+function extractPublisherIdFromUrl(value) {
+  const normalizedValue = normalizeNonEmptyString(value);
+  if (!normalizedValue) {
+    return void 0;
+  }
+  try {
+    const parsed = new URL(normalizedValue);
+    return normalizeGeneratedIdentifier(parsed.hostname.replace(/^www\./i, ""));
+  } catch {
+    return void 0;
+  }
+}
+function extractPublisherIdFromEmail(value) {
+  const normalizedValue = normalizeNonEmptyString(value);
+  if (!normalizedValue) {
+    return void 0;
+  }
+  const domain = normalizedValue.split("@")[1];
+  return domain ? normalizeGeneratedIdentifier(domain.replace(/^www\./i, "")) : void 0;
+}
+function resolveAutoGeneratedWapkAppId(packageName, fallbackName) {
+  const scopedPackage = parseScopedPackageName(packageName);
+  return joinGeneratedIdentifier(scopedPackage.scope, scopedPackage.packageName ?? fallbackName);
+}
+function resolveAutoGeneratedWapkPublisherId(packageJson, fallbackName) {
+  const scopedPackage = parseScopedPackageName(typeof packageJson?.name === "string" ? packageJson.name : void 0);
+  if (scopedPackage.scope) {
+    return normalizeGeneratedIdentifier(scopedPackage.scope);
+  }
+  const author = readPackageAuthorMetadata(packageJson?.author);
+  return extractPublisherIdFromRepository(packageJson?.repository) ?? extractPublisherIdFromUrl(packageJson?.homepage) ?? extractPublisherIdFromUrl(author.url) ?? extractPublisherIdFromEmail(author.email) ?? normalizeGeneratedIdentifier(author.name ?? fallbackName);
+}
 function normalizeStringMap(value) {
   if (!isRecord(value)) {
     return void 0;
@@ -74544,6 +74802,8 @@ function normalizeWapkConfig(value) {
     runtime: normalizeRuntime(value.runtime ?? value.engine),
     entry: typeof value.entry === "string" ? value.entry : void 0,
     scripts: normalizeStringMap(value.scripts ?? value.script),
+    appId: normalizeNonEmptyString(value.appId),
+    publisherId: normalizeNonEmptyString(value.publisherId),
     port: normalizePort(value.port),
     env: normalizeStringMap(value.env),
     desktop: normalizeDesktopConfig(value.desktop),
@@ -74833,6 +75093,7 @@ async function readWapkProjectConfig(directory) {
   const elitConfig = await loadConfig(directory);
   const elitWapkConfig = normalizeWapkConfig(elitConfig?.wapk);
   const packageJson = readJsonFile(packageJsonPath);
+  const packageJsonWapk = isRecord(packageJson?.wapk) ? packageJson.wapk : void 0;
   const packageScripts = normalizeStringMap(packageJson?.scripts) ?? {};
   const selectedScripts = elitWapkConfig.scripts ?? packageScripts;
   const inferred = inferRuntimeAndEntryFromScript(selectedScripts.start ?? packageScripts.start);
@@ -74856,12 +75117,16 @@ async function readWapkProjectConfig(directory) {
   if (!(0, import_node_fs2.existsSync)(entryPath) || !(0, import_node_fs2.statSync)(entryPath).isFile()) {
     throw new Error(`WAPK entry not found: ${entryPath}`);
   }
+  const appId = elitWapkConfig.appId ?? normalizeNonEmptyString(packageJson?.appId) ?? normalizeNonEmptyString(packageJsonWapk?.appId) ?? resolveAutoGeneratedWapkAppId(typeof packageJson?.name === "string" ? packageJson.name : void 0, name);
+  const publisherId = elitWapkConfig.publisherId ?? normalizeNonEmptyString(packageJson?.publisherId) ?? normalizeNonEmptyString(packageJsonWapk?.publisherId) ?? resolveAutoGeneratedWapkPublisherId(packageJson, name);
   return {
     name,
     version,
     runtime: runtime2,
     entry,
     scripts: selectedScripts,
+    appId,
+    publisherId,
     port: elitWapkConfig.port,
     env: elitWapkConfig.env,
     desktop: elitWapkConfig.desktop,
@@ -74871,11 +75136,14 @@ async function readWapkProjectConfig(directory) {
 function readIgnorePatterns(directory) {
   return readLineIgnorePatterns((0, import_node_path2.join)(directory, ".wapkignore"));
 }
+function parsePatternLines(content) {
+  return content.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && (!line.startsWith("#") || line.startsWith("\\#")));
+}
 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 parsePatternLines((0, import_node_fs2.readFileSync)(filePath, "utf8"));
 }
 function normalizePackageEntry(value) {
   const normalized = normalizeNonEmptyString(value)?.replace(/^[.][\\/]/, "").split("\\").join("/");
@@ -75056,23 +75324,188 @@ function resolveLinkedDependencyArchivePrefix(archivePrefix, dependencyName) {
   }
   return `${normalizedPrefix.slice(0, markerIndex + marker.length)}${dependencyName}`;
 }
-function shouldIgnore(relativePath2, ignorePatterns) {
-  const pathParts = relativePath2.split("/");
+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 (char === "?") {
+      regex += "[^/]";
+      continue;
+    }
+    regex += escapeRegex(char);
+  }
+  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) {
-    if (relativePath2 === pattern || pathParts.includes(pattern)) {
-      return true;
+    const normalizedRule = normalizeIgnorePattern(pattern);
+    if (!normalizedRule) {
+      continue;
     }
-    if (pattern.endsWith("*")) {
-      const prefix = pattern.slice(0, -1);
-      if (relativePath2.startsWith(prefix) || pathParts.some((part) => part.startsWith(prefix))) {
-        return true;
-      }
+    if (!matchesIgnorePattern(relativePath2, pattern, isDirectory)) {
+      continue;
     }
-    if (pattern.startsWith("*.") && relativePath2.endsWith(pattern.slice(1))) {
-      return true;
+    ignored = !normalizedRule.negate;
+  }
+  return ignored;
+}
+function matchesPatchPattern(relativePath2, pattern) {
+  const normalizedRule = normalizeIgnorePattern(pattern);
+  if (!normalizedRule) {
+    return false;
+  }
+  const normalizedPath = relativePath2.replace(/\\/g, "/");
+  const subtreeSelector = normalizedRule.pattern.endsWith("/*") && !normalizedRule.pattern.slice(0, -2).includes("*") && !normalizedRule.pattern.slice(0, -2).includes("?");
+  if (subtreeSelector) {
+    const directoryPath = normalizedRule.pattern.slice(0, -2);
+    return directoryPath.length > 0 && normalizedPath.startsWith(`${directoryPath}/`);
+  }
+  const hasGlob = /[*?]/.test(normalizedRule.pattern);
+  if (!hasGlob) {
+    if (normalizedRule.directoryOnly) {
+      return normalizedPath === normalizedRule.pattern || normalizedPath.startsWith(`${normalizedRule.pattern}/`);
+    }
+    return normalizedPath === normalizedRule.pattern;
+  }
+  return globPatternToRegex(normalizedRule.pattern, {
+    directoryOnly: normalizedRule.directoryOnly,
+    matchSegmentsOnly: false
+  }).test(normalizedPath);
+}
+function shouldPatchArchivePath(relativePath2, patchPatterns) {
+  let selected = false;
+  for (const pattern of patchPatterns) {
+    const normalizedRule = normalizeIgnorePattern(pattern);
+    if (!normalizedRule) {
+      continue;
+    }
+    if (!matchesPatchPattern(relativePath2, pattern)) {
+      continue;
     }
+    selected = !normalizedRule.negate;
+  }
+  return selected;
+}
+function resolvePatchManifestPatterns(files) {
+  const patchManifest = files.find((file) => file.path === ".wapkpatch");
+  if (!patchManifest) {
+    throw new Error("Patch archive must include a .wapkpatch manifest file.");
+  }
+  const patterns = parsePatternLines(patchManifest.content.toString("utf8"));
+  if (patterns.length === 0) {
+    throw new Error("Patch archive .wapkpatch must define at least one patch rule.");
+  }
+  return patterns;
+}
+function applyPatchEntriesToFiles(targetFiles, patchFiles) {
+  const fileMap = new Map(targetFiles.map((file) => [file.path, file]));
+  const fileOrder = targetFiles.map((file) => file.path);
+  const addedPaths = [];
+  const updatedPaths = [];
+  const unchangedPaths = [];
+  for (const patchFile of [...patchFiles].sort((left, right) => left.path.localeCompare(right.path))) {
+    const existing = fileMap.get(patchFile.path);
+    const nextEntry = {
+      path: patchFile.path,
+      content: Buffer.from(patchFile.content),
+      mode: patchFile.mode
+    };
+    if (!existing) {
+      addedPaths.push(patchFile.path);
+      fileOrder.push(patchFile.path);
+    } else if (existing.mode === patchFile.mode && existing.content.equals(patchFile.content)) {
+      unchangedPaths.push(patchFile.path);
+    } else {
+      updatedPaths.push(patchFile.path);
+    }
+    fileMap.set(patchFile.path, nextEntry);
   }
-  return false;
+  return {
+    files: fileOrder.map((filePath) => {
+      const file = fileMap.get(filePath);
+      if (!file) {
+        throw new Error(`Internal WAPK patch error: missing file entry for ${filePath}`);
+      }
+      return file;
+    }),
+    patchedPaths: [...updatedPaths, ...addedPaths],
+    addedPaths,
+    updatedPaths,
+    unchangedPaths
+  };
 }
 function collectFiles(directory, baseDirectory, ignorePatterns) {
   const files = [];
@@ -75080,7 +75513,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()) {
@@ -75229,6 +75662,8 @@ function decodeWapkPayload(buffer) {
     runtime: normalizeRuntime(rawHeader.runtime ?? rawHeader.engine) ?? "node",
     entry: typeof rawHeader.entry === "string" ? rawHeader.entry : "index.js",
     scripts: normalizeStringMap(rawHeader.scripts) ?? {},
+    appId: normalizeNonEmptyString(rawHeader.appId),
+    publisherId: normalizeNonEmptyString(rawHeader.publisherId),
     port: normalizePort(rawHeader.port),
     env: normalizeStringMap(rawHeader.env),
     desktop: normalizeDesktopConfig(rawHeader.desktop),
@@ -75726,11 +76161,14 @@ function sanitizeOnlineArchiveFileName(label, fallback) {
   const fileName = sanitized.length > 0 ? sanitized : "app.wapk";
   return fileName.toLowerCase().endsWith(".wapk") ? fileName : `${fileName}.wapk`;
 }
+var WAPK_ONLINE_JOIN_SOURCE_QUERY_PARAM = "launchSource";
+var WAPK_ONLINE_JOIN_SOURCE_QUERY_VALUE = "elit-wapk-online";
 function buildOnlineJoinUrl(baseUrl, joinKey) {
   const joinUrl = new URL(baseUrl.toString());
   joinUrl.search = "";
   joinUrl.hash = "";
   joinUrl.searchParams.set("join", joinKey);
+  joinUrl.searchParams.set(WAPK_ONLINE_JOIN_SOURCE_QUERY_PARAM, WAPK_ONLINE_JOIN_SOURCE_QUERY_VALUE);
   return joinUrl.toString();
 }
 async function probeOnlineLauncherUrl(url) {
@@ -75911,11 +76349,16 @@ async function closeWapkOnlineSharedSession(launcherUrl, session) {
 function isPmWapkOnlineShutdownEnabled() {
   return process.env[WAPK_ONLINE_PM_SHUTDOWN_ENV] === "1" && Boolean(process.stdin) && !process.stdin.isTTY;
 }
-async function waitForWapkOnlineSessionShutdown(launcherUrl, session, archiveHandle, lock) {
+function getWapkOnlineProcessDetails() {
+  return `pid ${process.pid}, ppid ${process.ppid}`;
+}
+async function waitForWapkOnlineSessionShutdown(launcherUrl, session, archiveHandle, lock, options = {}) {
   let snapshotRevision = 0;
   let snapshotSyncPending = false;
   let snapshotSyncPromise = Promise.resolve();
   let lastSnapshotSyncError = null;
+  const allowSigtermClose = options.allowSigtermClose === true;
+  const processDetails = getWapkOnlineProcessDetails();
   const syncGuestSnapshotUpdates = () => {
     if (snapshotSyncPending) {
       return snapshotSyncPromise;
@@ -75949,6 +76392,7 @@ async function waitForWapkOnlineSessionShutdown(launcherUrl, session, archiveHan
       void syncGuestSnapshotUpdates();
     }, WAPK_ONLINE_KEEPALIVE_INTERVAL_MS);
     const pmManaged = isPmWapkOnlineShutdownEnabled();
+    let ignoredSigTermLogged = false;
     let stdinBuffer = "";
     const cleanup = () => {
       clearInterval(keepAlive);
@@ -75967,7 +76411,17 @@ async function waitForWapkOnlineSessionShutdown(launcherUrl, session, archiveHan
       finish({ kind: "signal", signal: "SIGINT" });
     };
     const onSigTerm = () => {
-      finish({ kind: "signal", signal: "SIGTERM" });
+      if (allowSigtermClose) {
+        finish({ kind: "signal", signal: "SIGTERM" });
+        return;
+      }
+      if (ignoredSigTermLogged) {
+        return;
+      }
+      ignoredSigTermLogged = true;
+      console.warn(
+        pmManaged ? `[wapk] Ignoring SIGTERM while shared session ${session.joinKey} is active (${processDetails}). Use elit pm stop, restart, or delete to close the session.` : `[wapk] Ignoring SIGTERM while shared session ${session.joinKey} is active (${processDetails}). Press Ctrl+C to stop sharing, or pass --allow-sigterm-close to close on SIGTERM.`
+      );
     };
     const onStdinData = (chunk) => {
       stdinBuffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
@@ -75992,9 +76446,12 @@ async function waitForWapkOnlineSessionShutdown(launcherUrl, session, archiveHan
   if (shutdownTrigger.kind === "pm") {
     console.log(`
 [wapk] PM requested shutdown for shared session ${session.joinKey}...`);
+  } else if (shutdownTrigger.signal === "SIGTERM") {
+    console.log(`
+[wapk] Received SIGTERM for shared session ${session.joinKey} (${processDetails}); closing because --allow-sigterm-close is enabled...`);
   } else {
     console.log(`
-[wapk] Closing shared session ${session.joinKey}...`);
+[wapk] Received ${shutdownTrigger.signal}; closing shared session ${session.joinKey}...`);
   }
   try {
     await closeWapkOnlineSharedSession(launcherUrl, session);
@@ -76034,7 +76491,9 @@ async function runWapkOnline(archiveSpecifier, options) {
   process.exitCode = await waitForWapkOnlineSessionShutdown(launcherUrl, {
     joinKey: response.joinKey,
     adminToken: response.adminToken
-  }, archiveHandle, onlineArchiveLock);
+  }, archiveHandle, onlineArchiveLock, {
+    allowSigtermClose: options.allowSigtermClose
+  });
 }
 async function writeWapkArchiveFromMemory(archiveHandle, header, files, lock) {
   const updatedHeader = {
@@ -76291,6 +76750,8 @@ async function packWapkDirectory(directory, options = {}) {
     runtime: config.runtime,
     entry: config.entry,
     scripts: config.scripts,
+    appId: config.appId,
+    publisherId: config.publisherId,
     port: config.port,
     env: config.env,
     desktop: config.desktop,
@@ -76322,6 +76783,56 @@ function extractWapkArchive(wapkPath, outputDir = ".", options = {}) {
   console.log(`Extracted ${archive.files.length} files to: ${extractDirectory}`);
   return extractDirectory;
 }
+async function patchWapkArchive(wapkPath, options) {
+  const targetHandle = resolveArchiveHandle(wapkPath);
+  const targetSnapshot = await targetHandle.readSnapshot();
+  const targetEnvelope = parseWapkEnvelope(targetSnapshot.buffer);
+  const targetArchive = decodeWapk(targetSnapshot.buffer, options);
+  const targetLock = targetEnvelope.version === WAPK_LOCKED_VERSION ? resolveArchiveCredentials(options) : void 0;
+  const patchArchive = readWapkArchive(options.from, {
+    password: options.fromPassword ?? options.password
+  });
+  const patchPatterns = resolvePatchManifestPatterns(patchArchive.files);
+  const selectedPatchFiles = patchArchive.files.filter((file) => file.path !== ".wapkpatch").filter((file) => shouldPatchArchivePath(file.path, patchPatterns));
+  const patchResult = applyPatchEntriesToFiles(targetArchive.files, selectedPatchFiles);
+  console.log(`[wapk] Target: ${targetSnapshot.label ?? targetHandle.label}`);
+  console.log(`[wapk] Patch:  ${options.from}`);
+  console.log(`[wapk] Rules:  ${patchPatterns.length}`);
+  if (selectedPatchFiles.length === 0) {
+    console.log("[wapk] No files matched .wapkpatch. Archive was not modified.");
+    return {
+      archiveLabel: targetSnapshot.label ?? targetHandle.label,
+      patchedPaths: [],
+      addedPaths: [],
+      updatedPaths: [],
+      unchangedPaths: []
+    };
+  }
+  if (patchResult.patchedPaths.length === 0) {
+    console.log("[wapk] Matching patch files were already up to date. Archive was not modified.");
+    return {
+      archiveLabel: targetSnapshot.label ?? targetHandle.label,
+      patchedPaths: [],
+      addedPaths: [],
+      updatedPaths: [],
+      unchangedPaths: patchResult.unchangedPaths
+    };
+  }
+  const writeResult = await writeWapkArchiveFromMemory(
+    targetHandle,
+    targetArchive.header,
+    patchResult.files,
+    targetLock
+  );
+  console.log(`[wapk] Applied ${patchResult.patchedPaths.length} patch file${patchResult.patchedPaths.length === 1 ? "" : "s"}.`);
+  return {
+    archiveLabel: writeResult.label,
+    patchedPaths: patchResult.patchedPaths,
+    addedPaths: patchResult.addedPaths,
+    updatedPaths: patchResult.updatedPaths,
+    unchangedPaths: patchResult.unchangedPaths
+  };
+}
 async function prepareWapkApp(wapkPath, options = {}) {
   const archiveHandle = resolveArchiveHandle(wapkPath, options.googleDrive);
   const archivePath = archiveHandle.identifier;
@@ -76430,6 +76941,8 @@ function inspectWapkArchive(wapkPath, options = {}) {
   console.log(`App:      ${decoded.header.version}`);
   console.log(`Runtime:  ${decoded.header.runtime}`);
   console.log(`Entry:    ${decoded.header.entry}`);
+  console.log(`App ID:   ${decoded.header.appId ?? "n/a"}`);
+  console.log(`Publisher:${decoded.header.publisherId ? ` ${decoded.header.publisherId}` : " n/a"}`);
   console.log(`Port:     ${decoded.header.port ?? "default"}`);
   console.log(`Created:  ${decoded.header.createdAt}`);
   if (decoded.header.env && Object.keys(decoded.header.env).length > 0) {
@@ -76461,6 +76974,8 @@ function printWapkHelp() {
     "  elit wapk gdrive://<fileId> --online",
     "  elit wapk pack [directory]",
     "  elit wapk pack [directory] --password secret-123",
+    "  elit wapk patch <file.wapk> --from <patch.wapk>",
+    "  elit wapk patch <file.wapk> --use <patch.wapk>",
     "  elit wapk inspect <file.wapk>",
     "  elit wapk extract <file.wapk>",
     "",
@@ -76472,24 +76987,32 @@ function printWapkHelp() {
     "  --archive-watch              Pull external archive changes back into the temp workdir",
     "  --no-archive-watch           Disable external archive read sync",
     "  --online                     Create an Elit Run share session, stay alive, and close on Ctrl+C",
+    "  --allow-sigterm-close        Allow SIGTERM to close an online shared session",
     "  --online-url <url>           Elit Run URL (default: auto-detect localhost:4177 or localhost:4179)",
     "  --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",
+    "  --from <file.wapk>           Patch source archive for elit wapk patch",
+    "  --use <file.wapk>            Alias for --from",
+    "  --from-password <value>      Password for unlocking the patch archive",
     "  --include-deps               Legacy compatibility flag; node_modules are packed by default",
     "  --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.",
-    "  - Pack includes node_modules by default; use .wapkignore if you need to exclude them.",
+    "  - If appId or publisherId is not configured, pack auto-generates stable defaults from package metadata.",
+    "  - Pack includes node_modules by default; use .wapkignore if you need to exclude them, and !pattern to re-include later matches.",
+    "  - Patch reads .wapkpatch from the patch archive and applies only matching archive-relative paths.",
+    "  - Patch keeps the target archive metadata and lock mode; use --from-password when the patch archive uses a different password.",
     "  - 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.",
     "  - 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.",
     "  - Online mode creates a shared session on Elit Run directly, keeps the CLI alive, and closes it on Ctrl+C.",
+    "  - Online mode ignores SIGTERM by default; pass --allow-sigterm-close if an external supervisor should close the shared session with SIGTERM.",
     "  - Locked archives in online mode must provide --password so the CLI can build the shared snapshot.",
     "  - Locked archives require the same password for run/extract/inspect.",
     "  - Archives stay unlocked by default unless a password is provided.",
@@ -76539,6 +77062,7 @@ function parseRunArgs(args) {
   let archiveSyncInterval;
   let online;
   let onlineUrl;
+  let allowSigtermClose;
   let password;
   for (let index = 0; index < args.length; index++) {
     const arg = args[index];
@@ -76590,6 +77114,10 @@ function parseRunArgs(args) {
         onlineUrl = readRequiredOptionValue(args, ++index, "--online-url");
         break;
       }
+      case "--allow-sigterm-close": {
+        allowSigtermClose = true;
+        break;
+      }
       case "--google-drive-file-id": {
         googleDrive = {
           ...googleDrive,
@@ -76632,7 +77160,7 @@ function parseRunArgs(args) {
         break;
     }
   }
-  return { file, googleDrive, runtime: runtime2, syncInterval, useWatcher, watchArchive, archiveSyncInterval, online, onlineUrl, password };
+  return { file, googleDrive, runtime: runtime2, syncInterval, useWatcher, watchArchive, archiveSyncInterval, online, onlineUrl, allowSigtermClose, password };
 }
 function parsePackArgs(args) {
   let directory = ".";
@@ -76658,6 +77186,46 @@ function parsePackArgs(args) {
   }
   return { directory, includeDeps, password };
 }
+function parsePatchArgs(args) {
+  let file;
+  let from;
+  let password;
+  let fromPassword;
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    switch (arg) {
+      case "--from":
+      case "--use": {
+        if (from) {
+          throw new Error("WAPK patch accepts exactly one patch archive via --from or --use.");
+        }
+        from = readRequiredOptionValue(args, ++index, arg);
+        break;
+      }
+      case "--password": {
+        password = readRequiredOptionValue(args, ++index, "--password");
+        break;
+      }
+      case "--from-password": {
+        fromPassword = readRequiredOptionValue(args, ++index, "--from-password");
+        break;
+      }
+      default:
+        if (arg.startsWith("-")) {
+          throw new Error(`Unknown WAPK option: ${arg}`);
+        }
+        if (file) {
+          throw new Error("Usage: elit wapk patch <file.wapk> --from <patch.wapk>");
+        }
+        file = arg;
+        break;
+    }
+  }
+  if (!file || !from) {
+    throw new Error("Usage: elit wapk patch <file.wapk> --from <patch.wapk>");
+  }
+  return { file, from, password, fromPassword };
+}
 async function readConfiguredWapkRunDefaults(cwd) {
   const config = await loadConfig(cwd);
   const runConfig = normalizeWapkRunConfig(config?.wapk?.run);
@@ -76697,6 +77265,7 @@ function resolveConfiguredWapkRunOptions(options, defaults) {
     archiveSyncInterval: options.archiveSyncInterval ?? defaults?.archiveSyncInterval,
     online: options.online ?? defaults?.online ?? Boolean(onlineUrl),
     onlineUrl,
+    allowSigtermClose: options.allowSigtermClose === true,
     password: options.password ?? defaults?.password
   };
 }
@@ -76729,6 +77298,15 @@ async function runWapkCommand(args, cwd = process.cwd()) {
     });
     return;
   }
+  if (args[0] === "patch") {
+    const options = parsePatchArgs(args.slice(1));
+    await patchWapkArchive(options.file, {
+      from: options.from,
+      password: options.password,
+      fromPassword: options.fromPassword
+    });
+    return;
+  }
   if (args[0] === "inspect") {
     const options = parseArchiveAccessArgs(args.slice(1), "Usage: elit wapk inspect <file.wapk>");
     inspectWapkArchive(options.file, options);
@@ -76757,6 +77335,7 @@ async function runWapkCommand(args, cwd = process.cwd()) {
     await runWapkOnline(archiveSpecifier, {
       googleDrive: runOptions.googleDrive,
       onlineUrl: runOptions.onlineUrl,
+      allowSigtermClose: runOptions.allowSigtermClose,
       password: runOptions.password
     });
     return;
@@ -83080,6 +83659,7 @@ WAPK Options:
   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 patch <file.wapk> --from <patch.wapk>  Apply a manifest-driven patch 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