craft-native 0.0.37 → 0.0.49

package/dist/index.cjs

@@ -177,7 +177,7 @@ __export(exports_src, {
   focusFilters: () => focusFilters,
   focus: () => focus,
   exit: () => exit,
-  exec: () => exec2,
+  exec: () => exec,
   env: () => env,
   dialog: () => dialog,
   device: () => device,
@@ -290,16 +290,90 @@ function craftBinaryNotFoundMessage(triedPath) {
 
 // src/package.ts
 var import_child_process = require("child_process");
+var import_crypto = require("crypto");
 var import_fs = require("fs");
 var import_os = require("os");
 var import_path = require("path");
-var archiverFn = null;
-async function loadArchiver() {
-  if (!archiverFn) {
-    const mod = await import("archiver");
-    archiverFn = mod.default ?? mod;
-  }
-  return archiverFn;
+var import_zlib = require("zlib");
+var CRC32_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let n = 0;n < 256; n++) {
+    let c = n;
+    for (let k = 0;k < 8; k++)
+      c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    table[n] = c >>> 0;
+  }
+  return table;
+})();
+function crc32(data) {
+  let c = 4294967295;
+  for (let i = 0;i < data.length; i++)
+    c = CRC32_TABLE[(c ^ data[i]) & 255] ^ c >>> 8;
+  return (c ^ 4294967295) >>> 0;
+}
+function dosDateTime(d) {
+  const time = d.getHours() << 11 | d.getMinutes() << 5 | d.getSeconds() >> 1;
+  const date = d.getFullYear() - 1980 << 9 | d.getMonth() + 1 << 5 | d.getDate();
+  return { time: time & 65535, date: date & 65535 };
+}
+function buildZip(entries) {
+  const { time, date } = dosDateTime(new Date);
+  const locals = [];
+  const central = [];
+  let offset = 0;
+  for (const entry of entries) {
+    const nameBytes = Buffer.from(entry.name, "utf8");
+    const compressed = import_zlib.deflateRawSync(entry.data, { level: 9 });
+    const crc = crc32(entry.data);
+    const lfh = Buffer.alloc(30);
+    lfh.writeUInt32LE(67324752, 0);
+    lfh.writeUInt16LE(20, 4);
+    lfh.writeUInt16LE(0, 6);
+    lfh.writeUInt16LE(8, 8);
+    lfh.writeUInt16LE(time, 10);
+    lfh.writeUInt16LE(date, 12);
+    lfh.writeUInt32LE(crc, 14);
+    lfh.writeUInt32LE(compressed.length, 18);
+    lfh.writeUInt32LE(entry.data.length, 22);
+    lfh.writeUInt16LE(nameBytes.length, 26);
+    lfh.writeUInt16LE(0, 28);
+    locals.push(lfh, nameBytes, compressed);
+    const cdh = Buffer.alloc(46);
+    cdh.writeUInt32LE(33639248, 0);
+    cdh.writeUInt16LE(20, 4);
+    cdh.writeUInt16LE(20, 6);
+    cdh.writeUInt16LE(0, 8);
+    cdh.writeUInt16LE(8, 10);
+    cdh.writeUInt16LE(time, 12);
+    cdh.writeUInt16LE(date, 14);
+    cdh.writeUInt32LE(crc, 16);
+    cdh.writeUInt32LE(compressed.length, 20);
+    cdh.writeUInt32LE(entry.data.length, 24);
+    cdh.writeUInt16LE(nameBytes.length, 28);
+    cdh.writeUInt16LE(0, 30);
+    cdh.writeUInt16LE(0, 32);
+    cdh.writeUInt16LE(0, 34);
+    cdh.writeUInt16LE(0, 36);
+    cdh.writeUInt32LE(0, 38);
+    cdh.writeUInt32LE(offset, 42);
+    central.push(cdh, nameBytes);
+    offset += lfh.length + nameBytes.length + compressed.length;
+  }
+  const centralBuf = Buffer.concat(central);
+  const eocd = Buffer.alloc(22);
+  eocd.writeUInt32LE(101010256, 0);
+  eocd.writeUInt16LE(0, 4);
+  eocd.writeUInt16LE(0, 6);
+  eocd.writeUInt16LE(entries.length, 8);
+  eocd.writeUInt16LE(entries.length, 10);
+  eocd.writeUInt32LE(centralBuf.length, 12);
+  eocd.writeUInt32LE(offset, 16);
+  eocd.writeUInt16LE(0, 20);
+  return Buffer.concat([...locals, centralBuf, eocd]);
+}
+function formatPackagingCommandError(tool, code, stdout, stderr) {
+  const detail = `${stdout}${stderr}`.trim();
+  return `${tool} exited with code ${code}${detail ? `: ${detail}` : ""}`;
 }
 async function packageApp(config) {
   const results = [];
@@ -330,13 +404,20 @@ async function packageMacOS(config, outDir) {
   const results = [];
   const { name, version, bundleId = `com.myapp.${name.toLowerCase()}` } = config;
   const opts = config.macos || {};
+  const hardenedRuntime = !opts.appStore;
   const appBundlePath = import_path.join(outDir, `${name}.app`);
   const appBundle = createMacOSAppBundle({
     name,
     version,
     bundleId,
+    buildNumber: opts.buildNumber,
+    category: opts.category,
+    minimumSystemVersion: opts.minimumSystemVersion,
+    menuBarOnly: opts.menuBarOnly,
     binaryPath: config.binaryPath,
     iconPath: config.iconPath,
+    provisioningProfile: opts.provisioningProfile,
+    additionalExecutables: opts.additionalExecutables,
     outputPath: appBundlePath
   });
   if (!appBundle.success) {
@@ -348,12 +429,30 @@ async function packageMacOS(config, outDir) {
     });
     return results;
   }
-  if (opts.dmg !== false) {
-    const dmgResult = await createDMG({
-      appBundlePath,
-      outputPath: import_path.join(outDir, `${name}-${version}.dmg`),
-      volumeName: name
+  if (opts.signIdentity) {
+    const signed = await runTool("codesign", codesignArguments({
+      path: appBundlePath,
+      identity: opts.signIdentity,
+      entitlements: opts.entitlements,
+      hardenedRuntime
+    }));
+    if (!signed.success) {
+      results.push({ success: false, platform: "macos", format: "app", error: signed.error });
+      return results;
+    }
+  } else if (opts.appStore) {
+    results.push({
+      success: false,
+      platform: "macos",
+      format: "pkg",
+      error: 'App Store packaging requires macos.signIdentity (a "3rd Party Mac Developer Application" identity)'
     });
+    return results;
+  }
+  results.push({ success: true, platform: "macos", format: "app", outputPath: appBundlePath });
+  if (opts.dmg !== false) {
+    const outputPath = import_path.join(outDir, `${name}-${version}.dmg`);
+    const dmgResult = await createDMG({ appBundlePath, outputPath, volumeName: name });
     results.push({
       success: dmgResult.success,
       platform: "macos",
@@ -361,24 +460,59 @@ async function packageMacOS(config, outDir) {
       outputPath: dmgResult.outputPath,
       error: dmgResult.error
     });
+    if (dmgResult.success)
+      results.push(...await notarizeIfRequested(opts, outputPath, "dmg"));
   }
-  if (opts.pkg) {
+  if (opts.pkg || opts.appStore) {
+    const outputPath = import_path.join(outDir, `${name}-${version}.pkg`);
     const pkgResult = await createPKG({
       appBundlePath,
-      outputPath: import_path.join(outDir, `${name}-${version}.pkg`),
+      outputPath,
       identifier: bundleId,
-      version
+      version,
+      appStore: opts.appStore === true,
+      installerIdentity: opts.installerIdentity
     });
     results.push({
       success: pkgResult.success,
       platform: "macos",
-      format: "pkg",
+      format: opts.appStore ? "pkg (app store)" : "pkg",
       outputPath: pkgResult.outputPath,
       error: pkgResult.error
     });
+    if (pkgResult.success && !opts.appStore)
+      results.push(...await notarizeIfRequested(opts, outputPath, "pkg"));
   }
   return results;
 }
+async function notarizeIfRequested(opts, artifactPath, format) {
+  if (!opts.notarize)
+    return [];
+  if (!opts.appleId || !opts.applePassword || !opts.teamId) {
+    return [{
+      success: false,
+      platform: "macos",
+      format: `${format} (notarize)`,
+      error: "Notarization requires macos.appleId, macos.applePassword and macos.teamId"
+    }];
+  }
+  const submitted = await runTool("xcrun", notarytoolArguments({
+    artifactPath,
+    appleId: opts.appleId,
+    applePassword: opts.applePassword,
+    teamId: opts.teamId
+  }));
+  if (!submitted.success)
+    return [{ success: false, platform: "macos", format: `${format} (notarize)`, error: submitted.error }];
+  const stapled = await runTool("xcrun", ["stapler", "staple", artifactPath]);
+  return [{
+    success: stapled.success,
+    platform: "macos",
+    format: `${format} (notarize)`,
+    outputPath: stapled.success ? artifactPath : undefined,
+    error: stapled.success ? undefined : stapled.error
+  }];
+}
 async function packageWindows(config, outDir) {
   const results = [];
   const { name, version } = config;
@@ -389,7 +523,10 @@ async function packageWindows(config, outDir) {
       version,
       binaryPath: config.binaryPath,
       outputPath: import_path.join(outDir, `${name}-${version}.msi`),
-      manufacturer: config.author || "Unknown"
+      manufacturer: config.author || "Unknown",
+      architecture: opts.architecture || windowsArchitecture(process.arch),
+      certificatePath: opts.certificatePath,
+      certificatePassword: opts.certificatePassword
     });
     results.push({
       success: msiResult.success,
@@ -473,83 +610,200 @@ async function packageLinux(config, outDir) {
   }
   return results;
 }
-function createMacOSAppBundle(opts) {
-  try {
-    const { name, version, bundleId, binaryPath, outputPath } = opts;
-    import_fs.mkdirSync(import_path.join(outputPath, "Contents", "MacOS"), { recursive: true });
-    import_fs.mkdirSync(import_path.join(outputPath, "Contents", "Resources"), { recursive: true });
-    import_fs.copyFileSync(binaryPath, import_path.join(outputPath, "Contents", "MacOS", name));
-    import_fs.chmodSync(import_path.join(outputPath, "Contents", "MacOS", name), 493);
-    const infoPlist = `<?xml version="1.0" encoding="UTF-8"?>
+function macOSInfoPlist(metadata) {
+  const entries = [
+    ["CFBundleExecutable", metadata.name],
+    ["CFBundleIdentifier", metadata.bundleId],
+    ["CFBundleName", metadata.name],
+    ["CFBundleShortVersionString", metadata.version],
+    ["CFBundleVersion", metadata.buildNumber || metadata.version],
+    ["CFBundlePackageType", "APPL"],
+    ["NSHighResolutionCapable", true]
+  ];
+  if (metadata.iconName)
+    entries.push(["CFBundleIconFile", metadata.iconName]);
+  if (metadata.category)
+    entries.push(["LSApplicationCategoryType", metadata.category]);
+  if (metadata.minimumSystemVersion)
+    entries.push(["LSMinimumSystemVersion", metadata.minimumSystemVersion]);
+  if (metadata.menuBarOnly)
+    entries.push(["LSUIElement", true]);
+  const body = entries.map(([key, value]) => `    <key>${xml(key)}</key>
+${value === true ? "    <true/>" : `    <string>${xml(value)}</string>`}`).join(`
+`);
+  return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
-    <key>CFBundleExecutable</key>
-    <string>${name}</string>
-    <key>CFBundleIdentifier</key>
-    <string>${bundleId}</string>
-    <key>CFBundleName</key>
-    <string>${name}</string>
-    <key>CFBundleShortVersionString</key>
-    <string>${version}</string>
-    <key>CFBundleVersion</key>
-    <string>${version}</string>
-    <key>CFBundlePackageType</key>
-    <string>APPL</string>
-    <key>NSHighResolutionCapable</key>
-    <true/>
+${body}
 </dict>
 </plist>`;
-    import_fs.writeFileSync(import_path.join(outputPath, "Contents", "Info.plist"), infoPlist);
+}
+function codesignArguments(opts) {
+  return [
+    "--force",
+    "--sign",
+    opts.identity,
+    "--timestamp",
+    ...opts.hardenedRuntime ? ["--options", "runtime"] : [],
+    ...opts.entitlements ? ["--entitlements", opts.entitlements] : [],
+    "--deep",
+    opts.path
+  ];
+}
+function productbuildArguments(opts) {
+  return [
+    "--component",
+    opts.appBundlePath,
+    "/Applications",
+    "--sign",
+    opts.identity,
+    opts.outputPath
+  ];
+}
+function notarytoolArguments(opts) {
+  return [
+    "notarytool",
+    "submit",
+    opts.artifactPath,
+    "--apple-id",
+    opts.appleId,
+    "--password",
+    opts.applePassword,
+    "--team-id",
+    opts.teamId,
+    "--wait"
+  ];
+}
+function createMacOSAppBundle(opts) {
+  try {
+    const { name, binaryPath, iconPath, provisioningProfile, additionalExecutables, outputPath } = opts;
+    const contents = import_path.join(outputPath, "Contents");
+    const macOS = import_path.join(contents, "MacOS");
+    import_fs.mkdirSync(macOS, { recursive: true });
+    import_fs.mkdirSync(import_path.join(contents, "Resources"), { recursive: true });
+    import_fs.copyFileSync(binaryPath, import_path.join(macOS, name));
+    import_fs.chmodSync(import_path.join(macOS, name), 493);
+    for (const executable of additionalExecutables || []) {
+      if (!import_fs.existsSync(executable))
+        return { success: false, error: `Additional executable not found: ${executable}` };
+      const destination = import_path.join(macOS, import_path.basename(executable));
+      import_fs.copyFileSync(executable, destination);
+      import_fs.chmodSync(destination, 493);
+    }
+    let iconName;
+    if (iconPath) {
+      if (!import_fs.existsSync(iconPath))
+        return { success: false, error: `Icon not found: ${iconPath}` };
+      iconName = import_path.basename(iconPath).replace(/\.icns$/i, "");
+      import_fs.copyFileSync(iconPath, import_path.join(contents, "Resources", `${iconName}.icns`));
+    }
+    if (provisioningProfile) {
+      if (!import_fs.existsSync(provisioningProfile))
+        return { success: false, error: `Provisioning profile not found: ${provisioningProfile}` };
+      import_fs.copyFileSync(provisioningProfile, import_path.join(contents, "embedded.provisionprofile"));
+    }
+    import_fs.writeFileSync(import_path.join(contents, "Info.plist"), macOSInfoPlist({ ...opts, iconName }));
     return { success: true };
   } catch (error) {
     return { success: false, error: error.message };
   }
 }
-async function createDMG(opts) {
+var MEBIBYTE = 1024 * 1024;
+function pathContentBytes(path) {
+  const stat = import_fs.lstatSync(path);
+  if (!stat.isDirectory())
+    return stat.size;
+  return import_fs.readdirSync(path).reduce((total, entry) => total + pathContentBytes(import_path.join(path, entry)), 0);
+}
+function dmgCapacityMegabytes(contentBytes) {
+  if (!Number.isSafeInteger(contentBytes) || contentBytes < 0)
+    throw new Error(`DMG content size must be a non-negative safe integer: ${contentBytes}`);
+  const contentMegabytes = Math.ceil(contentBytes / MEBIBYTE);
+  return Math.max(64, Math.ceil(contentMegabytes * 1.25) + 32);
+}
+function dmgCreateArguments(opts, contentBytes) {
+  return [
+    "create",
+    "-volname",
+    opts.volumeName,
+    "-srcfolder",
+    opts.appBundlePath,
+    "-size",
+    `${dmgCapacityMegabytes(contentBytes)}m`,
+    "-ov",
+    "-format",
+    "UDZO",
+    opts.outputPath
+  ];
+}
+var HDIUTIL_MAX_ATTEMPTS = 3;
+function shouldRetryHdiutil(error, attempt, maxAttempts = HDIUTIL_MAX_ATTEMPTS) {
+  if (!Number.isInteger(attempt) || attempt < 1 || !Number.isInteger(maxAttempts) || maxAttempts < 1)
+    throw new Error("hdiutil retry attempts must be positive integers");
+  return attempt < maxAttempts && /(?:resource busy|resource temporarily unavailable)/i.test(error);
+}
+function runTool(tool, args) {
   return new Promise((resolve) => {
-    if (!/^[^/:\n]{1,27}$/.test(opts.volumeName)) {
-      resolve({ success: false, error: `Invalid DMG volume name "${opts.volumeName}"; must be 1..27 chars without /, :, or newline` });
-      return;
-    }
-    const proc = import_child_process.spawn("hdiutil", [
-      "create",
-      "-volname",
-      opts.volumeName,
-      "-srcfolder",
-      opts.appBundlePath,
-      "-ov",
-      "-format",
-      "UDZO",
-      opts.outputPath
-    ]);
-    proc.on("close", (code) => {
-      if (code === 0) {
-        resolve({ success: true, outputPath: opts.outputPath });
-      } else {
-        resolve({ success: false, error: `hdiutil exited with code ${code}` });
-      }
+    const proc = import_child_process.spawn(tool, args);
+    let stdout = "";
+    let stderr = "";
+    proc.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
     });
-    proc.on("error", (err) => {
-      resolve({ success: false, error: err.message });
+    proc.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString();
     });
+    proc.on("close", (code) => {
+      if (code === 0)
+        resolve({ success: true });
+      else
+        resolve({ success: false, error: formatPackagingCommandError(tool, code, stdout, stderr) });
+    });
+    proc.on("error", (err) => resolve({ success: false, error: err.message }));
   });
 }
+var runHdiutil = (args) => runTool("hdiutil", args);
+async function createDMG(opts) {
+  if (!/^[^/:\n]{1,27}$/.test(opts.volumeName))
+    return { success: false, error: `Invalid DMG volume name "${opts.volumeName}"; must be 1..27 chars without /, :, or newline` };
+  const args = dmgCreateArguments(opts, pathContentBytes(opts.appBundlePath));
+  const failures = [];
+  for (let attempt = 1;attempt <= HDIUTIL_MAX_ATTEMPTS; attempt++) {
+    const result = await runHdiutil(args);
+    if (result.success)
+      return { success: true, outputPath: opts.outputPath };
+    failures.push(`attempt ${attempt}: ${result.error}`);
+    if (!shouldRetryHdiutil(result.error, attempt))
+      return { success: false, error: failures.join(`
+`) };
+    import_fs.rmSync(opts.outputPath, { force: true });
+    await new Promise((resolve) => setTimeout(resolve, attempt * 2000));
+  }
+  return { success: false, error: failures.join(`
+`) };
+}
 async function createPKG(opts) {
-  return new Promise((resolve) => {
-    if (!/^[a-zA-Z0-9._-]+$/.test(opts.identifier) || !opts.identifier.includes(".")) {
-      resolve({ success: false, error: `Invalid pkg identifier "${opts.identifier}"; expected reverse-DNS like com.example.app` });
-      return;
-    }
-    if (!/^[A-Za-z0-9._+-]+$/.test(opts.version)) {
-      resolve({ success: false, error: `Invalid pkg version "${opts.version}"` });
-      return;
-    }
-    const tempDir = import_fs.mkdtempSync(import_path.join(import_os.tmpdir(), "craft-pkg-"));
+  if (!/^[a-zA-Z0-9._-]+$/.test(opts.identifier) || !opts.identifier.includes("."))
+    return { success: false, error: `Invalid pkg identifier "${opts.identifier}"; expected reverse-DNS like com.example.app` };
+  if (!/^[A-Za-z0-9._+-]+$/.test(opts.version))
+    return { success: false, error: `Invalid pkg version "${opts.version}"` };
+  if (opts.appStore) {
+    if (!opts.installerIdentity)
+      return { success: false, error: 'App Store packaging requires macos.installerIdentity (a "3rd Party Mac Developer Installer" identity)' };
+    const built = await runTool("productbuild", productbuildArguments({
+      appBundlePath: opts.appBundlePath,
+      outputPath: opts.outputPath,
+      identity: opts.installerIdentity
+    }));
+    return built.success ? { success: true, outputPath: opts.outputPath } : { success: false, error: built.error };
+  }
+  const tempDir = import_fs.mkdtempSync(import_path.join(import_os.tmpdir(), "craft-pkg-"));
+  try {
     const appsDir = import_path.join(tempDir, "Applications");
     import_fs.mkdirSync(appsDir, { recursive: true });
     import_fs.cpSync(opts.appBundlePath, import_path.join(appsDir, import_path.basename(opts.appBundlePath)), { recursive: true });
-    const proc = import_child_process.spawn("pkgbuild", [
+    const built = await runTool("pkgbuild", [
       "--root",
       tempDir,
       "--identifier",
@@ -558,64 +812,116 @@ async function createPKG(opts) {
       opts.version,
       "--install-location",
       "/",
+      ...opts.installerIdentity ? ["--sign", opts.installerIdentity] : [],
       opts.outputPath
     ]);
-    proc.on("close", (code) => {
-      import_fs.rmSync(tempDir, { recursive: true, force: true });
-      if (code === 0) {
-        resolve({ success: true, outputPath: opts.outputPath });
-      } else {
-        resolve({ success: false, error: `pkgbuild exited with code ${code}` });
-      }
-    });
-    proc.on("error", (err) => {
-      import_fs.rmSync(tempDir, { recursive: true, force: true });
-      resolve({ success: false, error: err.message });
-    });
-  });
+    return built.success ? { success: true, outputPath: opts.outputPath } : { success: false, error: built.error };
+  } finally {
+    import_fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+function xml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll(`'`, "&apos;");
+}
+function wixIdentifier(value) {
+  const sanitized = value.replace(/[^A-Za-z0-9_.]/g, "_");
+  return /^[A-Za-z_]/.test(sanitized) ? sanitized : `_${sanitized}`;
+}
+function deterministicGuid(value) {
+  const digest = import_crypto.createHash("sha256").update(value).digest("hex").slice(0, 32).split("");
+  digest[12] = "4";
+  digest[16] = (Number.parseInt(digest[16], 16) & 3 | 8).toString(16);
+  const hex = digest.join("").toUpperCase();
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function windowsArchitecture(architecture) {
+  if (architecture === "ia32" || architecture === "x86")
+    return "x86";
+  if (architecture === "x64" || architecture === "arm64")
+    return architecture;
+  throw new Error(`Unsupported Windows package architecture: ${architecture}`);
+}
+function renderWixSource(opts, sourceName) {
+  if (!/^[0-9]+\.[0-9]+\.[0-9]+(?:\.[0-9]+)?$/.test(opts.version))
+    throw new Error(`MSI version must have 3 or 4 numeric parts: ${opts.version}`);
+  const id = wixIdentifier(opts.name);
+  const manufacturer = opts.manufacturer.trim() || "Unknown";
+  const upgradeCode = deterministicGuid(`${manufacturer}/${opts.name}`);
+  const programFilesFolder = opts.architecture === "x86" ? "ProgramFilesFolder" : "ProgramFiles64Folder";
+  const win64 = opts.architecture === "x86" ? "no" : "yes";
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<Wix xmlns="http://schemas.microsoft.com/wix/2006/wi">
+  <Product Id="*" Name="${xml(opts.name)}" Language="1033" Version="${opts.version}" Manufacturer="${xml(manufacturer)}" UpgradeCode="${upgradeCode}">
+    <Package InstallerVersion="500" Compressed="yes" InstallScope="perMachine" Platform="${opts.architecture}" />
+    <MajorUpgrade AllowDowngrades="yes" />
+    <MediaTemplate EmbedCab="yes" />
+    <Directory Id="TARGETDIR" Name="SourceDir">
+      <Directory Id="${programFilesFolder}">
+        <Directory Id="INSTALLFOLDER" Name="${xml(opts.name)}">
+          <Component Id="${id}Executable" Guid="*" Win64="${win64}">
+            <File Id="${id}File" Source="${xml(sourceName)}" KeyPath="yes" />
+          </Component>
+        </Directory>
+      </Directory>
+    </Directory>
+    <Feature Id="ProductFeature" Title="${xml(opts.name)}" Level="1">
+      <ComponentRef Id="${id}Executable" />
+    </Feature>
+  </Product>
+</Wix>
+`;
 }
-async function createMSI(_opts) {
-  return new Promise((resolve) => {
-    import_child_process.exec("candle.exe -?", (error) => {
-      if (error) {
-        resolve({
-          success: false,
-          error: "WiX Toolset not found. Install from https://wixtoolset.org/"
-        });
-      } else {
-        resolve({
-          success: false,
-          error: "MSI creation requires Windows platform and WiX Toolset"
-        });
-      }
-    });
+function windowsExecutableName(name) {
+  if (name.length === 0 || name.trim() !== name || /[<>:"/\\|?*\u0000-\u001F]/.test(name) || /[. ]$/.test(name))
+    throw new Error(`Invalid Windows application name: ${JSON.stringify(name)}`);
+  if (/^(?:CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(?:\.|$)/i.test(name))
+    throw new Error(`Reserved Windows application name: ${JSON.stringify(name)}`);
+  return `${name}.exe`;
+}
+function runCommand(command, args, cwd) {
+  return new Promise((resolve, reject) => {
+    const child = import_child_process.spawn(command, args, { cwd, stdio: "inherit", windowsHide: true });
+    child.once("error", reject);
+    child.once("close", (code) => code === 0 ? resolve() : reject(new Error(`${command} exited with code ${code}`)));
   });
 }
+async function createMSI(opts) {
+  const tempDir = import_fs.mkdtempSync(import_path.join(import_os.tmpdir(), "craft-msi-"));
+  try {
+    const binaryName = windowsExecutableName(opts.name);
+    const sourcePath = import_path.join(tempDir, binaryName);
+    const wxsPath = import_path.join(tempDir, "installer.wxs");
+    const wixobjPath = import_path.join(tempDir, "installer.wixobj");
+    import_fs.copyFileSync(opts.binaryPath, sourcePath);
+    import_fs.writeFileSync(wxsPath, renderWixSource(opts, binaryName));
+    await runCommand("candle.exe", ["-nologo", "-out", wixobjPath, wxsPath], tempDir);
+    await runCommand("light.exe", ["-nologo", "-sval", "-out", opts.outputPath, wixobjPath], tempDir);
+    if (opts.certificatePath) {
+      const signArgs = ["sign", "/fd", "sha256", "/tr", "https://timestamp.digicert.com", "/td", "sha256", "/f", opts.certificatePath];
+      if (opts.certificatePassword)
+        signArgs.push("/p", opts.certificatePassword);
+      signArgs.push(opts.outputPath);
+      await runCommand("signtool.exe", signArgs);
+      await runCommand("signtool.exe", ["verify", "/pa", "/all", opts.outputPath]);
+    }
+    return { success: true, outputPath: opts.outputPath };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const missingTool = /ENOENT|not found/i.test(message);
+    return { success: false, error: missingTool ? `WiX Toolset not found: ${message}` : message };
+  } finally {
+    import_fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+}
 async function createZIP(opts) {
-  const archiverFn2 = await loadArchiver();
-  return new Promise((resolve) => {
-    const output = import_fs.createWriteStream(opts.outputPath);
-    const archive = archiverFn2("zip", { zlib: { level: 9 } });
-    let settled = false;
-    const settle = (r) => {
-      if (settled)
-        return;
-      settled = true;
-      resolve(r);
-    };
-    output.on("close", () => {
-      settle({ success: true, outputPath: opts.outputPath });
-    });
-    output.on("error", (err) => {
-      settle({ success: false, error: `Failed to write ZIP: ${err.message}` });
-    });
-    archive.on("error", (err) => {
-      settle({ success: false, error: err.message });
-    });
-    archive.pipe(output);
-    archive.file(opts.binaryPath, { name: `${opts.name}.exe` });
-    archive.finalize();
-  });
+  try {
+    const data = new Uint8Array(import_fs.readFileSync(opts.binaryPath));
+    const zip = buildZip([{ name: `${opts.name}.exe`, data }]);
+    import_fs.writeFileSync(opts.outputPath, zip);
+    return { success: true, outputPath: opts.outputPath };
+  } catch (err) {
+    return { success: false, error: `Failed to write ZIP: ${err.message}` };
+  }
 }
 async function createDEB(opts) {
   return new Promise((resolve) => {
@@ -2082,6 +2388,9 @@ class Window {
   async setPosition(x, y, animate) {
     await this._call("setPosition", { x, y, animate });
   }
+  async moveBy(dx, dy) {
+    await this._call("moveBy", { dx, dy });
+  }
   async getPosition() {
     return this._call("getPosition");
   }
@@ -2109,6 +2418,9 @@ class Window {
   async setMovable(movable) {
     await this._call("setMovable", { movable });
   }
+  async startDrag() {
+    await this._call("startDrag");
+  }
   async isMovable() {
     return this._call("isMovable");
   }
@@ -2226,12 +2538,14 @@ class WindowManager {
   setTitle = (title) => this.current.setTitle(title);
   setSize = (width, height, animate) => this.current.setSize(width, height, animate);
   setPosition = (x, y, animate) => this.current.setPosition(x, y, animate);
+  moveBy = (dx, dy) => this.current.moveBy(dx, dy);
   setBounds = (bounds, animate) => this.current.setBounds(bounds, animate);
   setAlwaysOnTop = (alwaysOnTop) => this.current.setAlwaysOnTop(alwaysOnTop);
   setOpacity = (opacity) => this.current.setOpacity(opacity);
   setBackgroundColor = (color) => this.current.setBackgroundColor(color);
   setVibrancy = (vibrancy) => this.current.setVibrancy(vibrancy);
   setResizable = (resizable) => this.current.setResizable(resizable);
+  startDrag = () => this.current.startDrag();
   getState = () => this.current.getState();
   on = (event, handler) => this.current.on(event, handler);
   once = (event, handler) => this.current.once(event, handler);
@@ -3674,8 +3988,8 @@ var crypto = {
       if (!hasNodeCrypto) {
         throw new CraftCryptoError("MD5 is not available in this runtime — WebCrypto does not implement it. " + "Use sha256/sha512, or call this from Node.");
       }
-      const { createHash: createHash2 } = await import("node:crypto");
-      return createHash2("md5").update(data).digest("hex");
+      const { createHash: createHash3 } = await import("node:crypto");
+      return createHash3("md5").update(data).digest("hex");
     }
     if (typeof globalThis.crypto !== "undefined" && globalThis.crypto.subtle) {
       const encoder = new TextEncoder;
@@ -3683,8 +3997,8 @@ var crypto = {
       const hashBuffer = await globalThis.crypto.subtle.digest(algorithm === "sha256" ? "SHA-256" : "SHA-512", dataBuffer);
       return bufferToHex(hashBuffer);
     }
-    const { createHash } = await import("node:crypto");
-    return createHash(algorithm).update(data).digest("hex");
+    const { createHash: createHash2 } = await import("node:crypto");
+    return createHash2(algorithm).update(data).digest("hex");
   },
   async encrypt(data, key) {
     if (typeof window !== "undefined" && window.craft?.crypto) {
@@ -3999,7 +4313,7 @@ async function getSystemInfo() {
     uptime: 0
   };
 }
-async function exec2(command, options) {
+async function exec(command, options) {
   if (typeof window !== "undefined" && window.craft) {
     return callBridge3("process.exec", { command, ...options });
   }
@@ -4179,18 +4493,18 @@ async function open(target) {
   const platform = getPlatform();
   const { execFile } = await import("node:child_process");
   const { promisify } = await import("node:util");
-  const exec3 = promisify(execFile);
+  const exec2 = promisify(execFile);
   switch (platform) {
     case "darwin":
     case "macos":
-      await exec3("open", [target]);
+      await exec2("open", [target]);
       return;
     case "win32":
     case "windows":
-      await exec3("cmd.exe", ["/c", "start", '""', target]);
+      await exec2("cmd.exe", ["/c", "start", '""', target]);
       return;
     case "linux":
-      await exec3("xdg-open", [target]);
+      await exec2("xdg-open", [target]);
       return;
     default:
       throw new Error(`Unsupported platform: ${platform}`);
@@ -8169,9 +8483,9 @@ async function buildCSS(options) {
     console.warn("buildCSS can only be run in Node.js environment");
     return;
   }
-  const { exec: exec3 } = await import("child_process");
+  const { exec: exec2 } = await import("child_process");
   const { promisify } = await import("util");
-  const execAsync = promisify(exec3);
+  const execAsync = promisify(exec2);
   const args = [
     "build",
     "--content",
@@ -8192,109 +8506,123 @@ async function buildCSS(options) {
 // src/styles/sidebars.ts
 var tahoeStyles = {
   sidebar: `
-    w-56 h-full flex flex-col
-    bg-white/70 dark:bg-neutral-900/70
-    backdrop-blur-xl backdrop-saturate-150
-    border-r border-black/5 dark:border-white/5
+    w-[250px] h-full flex flex-col
+    bg-white/55 dark:bg-[#1e1e23]/55
+    backdrop-blur-[60px] backdrop-saturate-[1.8]
+    text-black dark:text-white
     select-none
   `,
   content: `
     flex-1 overflow-y-auto overflow-x-hidden
-    py-2 px-2
-    scrollbar-thin scrollbar-thumb-black/10 dark:scrollbar-thumb-white/10
+    px-[10px] pb-[10px]
   `,
   section: `
-    mb-4
+    flex flex-col gap-[2px]
   `,
   sectionHeader: `
-    px-2 py-1.5 mb-1
-    text-[11px] font-semibold uppercase tracking-wider
-    text-neutral-500 dark:text-neutral-400
+    pl-[8px] pr-[6px] pt-[16px] pb-[5px]
+    text-[11px] font-semibold leading-[13px]
+    text-[#3c3c43]/60 dark:text-[#ebebf5]/60
   `,
   sectionHeaderCollapsible: `
-    px-2 py-1.5 mb-1 flex items-center gap-1 cursor-pointer
-    text-[11px] font-semibold uppercase tracking-wider
-    text-neutral-500 dark:text-neutral-400
-    hover:text-neutral-700 dark:hover:text-neutral-200
-    transition-colors duration-150
+    group flex items-center w-full
+    pl-[8px] pr-[6px] pt-[16px] pb-[5px]
+    text-[11px] font-semibold leading-[13px]
+    text-[#3c3c43]/60 dark:text-[#ebebf5]/60
+    cursor-default
   `,
   collapseChevron: `
-    w-3 h-3 transition-transform duration-200
+    ml-auto h-[11px] w-[11px]
+    text-[#3c3c43]/45 dark:text-[#ebebf5]/45
+    opacity-0 group-hover:opacity-100
+    transition-all duration-200
   `,
   item: `
-    flex items-center gap-2.5 px-2 py-1.5 mx-1 rounded-md
-    text-[13px] text-neutral-700 dark:text-neutral-200
-    cursor-pointer transition-all duration-150
-    hover:bg-black/5 dark:hover:bg-white/5
+    flex w-full items-center
+    h-[30px] rounded-[9px] pl-[4px] pr-[8px]
+    text-[13px] leading-[16px] text-black dark:text-white
+    cursor-default transition-colors duration-150 ease-out
+    hover:bg-black/4 dark:hover:bg-white/6
+    active:bg-black/10 dark:active:bg-white/18
   `,
   itemSelected: `
-    flex items-center gap-2.5 px-2 py-1.5 mx-1 rounded-md
-    text-[13px] text-white
-    cursor-pointer
-    bg-blue-500 dark:bg-blue-600
-    shadow-sm
+    flex w-full items-center
+    h-[30px] rounded-[9px] pl-[4px] pr-[8px]
+    text-[13px] leading-[16px] text-black dark:text-white
+    cursor-default
+    bg-black/8 dark:bg-white/14
+  `,
+  disclosure: `
+    flex h-[16px] w-[18px] shrink-0 items-center justify-center
+  `,
+  disclosureChevron: `
+    h-[11px] w-[11px]
+    text-[#3c3c43]/55 dark:text-[#ebebf5]/55
+    transition-transform duration-200 ease-out
   `,
   itemIcon: `
-    w-4 h-4 flex-shrink-0
-    text-neutral-500 dark:text-neutral-400
+    h-[17px] w-[17px] flex-shrink-0
+    text-[#0088ff]
   `,
   itemIconSelected: `
-    w-4 h-4 flex-shrink-0
-    text-white/90
+    h-[17px] w-[17px] flex-shrink-0
+    text-[#0088ff]
+  `,
+  itemIconSlot: `
+    flex h-[20px] w-[22px] shrink-0 items-center justify-center mr-[7px]
   `,
   itemLabel: `
     flex-1 truncate
   `,
   itemBadge: `
-    px-1.5 py-0.5 rounded-full text-[10px] font-medium
-    bg-neutral-200 dark:bg-neutral-700
-    text-neutral-600 dark:text-neutral-300
+    ml-[8px] shrink-0 tabular-nums
+    text-[13px] leading-[16px]
+    text-[#3c3c43]/60 dark:text-[#ebebf5]/60
   `,
   itemBadgeSelected: `
-    px-1.5 py-0.5 rounded-full text-[10px] font-medium
-    bg-white/20 text-white
+    ml-[8px] shrink-0 tabular-nums
+    text-[13px] leading-[16px]
+    text-[#3c3c43]/60 dark:text-[#ebebf5]/60
   `,
   children: `
-    ml-4 mt-0.5 border-l border-neutral-200 dark:border-neutral-700
+    ml-[16px] mt-[2px] flex flex-col gap-[2px]
   `,
   dragIndicator: `
-    absolute left-0 right-0 h-0.5 bg-blue-500
+    absolute left-0 right-0 h-0.5 bg-[#0088ff]
     pointer-events-none
   `,
   searchContainer: `
-    px-2 pb-2
+    px-[10px] pb-[6px]
   `,
   searchInput: `
-    w-full px-3 py-1.5 rounded-md
-    text-[13px] placeholder:text-neutral-400
-    bg-black/5 dark:bg-white/5
+    h-[28px] w-full rounded-[8px] px-[8px]
+    text-[13px] text-black dark:text-white
+    placeholder:text-[#3c3c43]/50 dark:placeholder:text-[#ebebf5]/50
+    bg-black/5 dark:bg-white/10
     border border-transparent
-    focus:outline-none focus:border-blue-500/50 focus:bg-white dark:focus:bg-neutral-800
+    focus:outline-none focus:ring-2 focus:ring-[#0088ff]/60
     transition-all duration-150
   `,
   header: `
-    px-3 py-3 border-b border-black/5 dark:border-white/5
-    flex items-center gap-3
+    h-[52px] px-[21px] flex items-center gap-3
   `,
   headerAvatar: `
-    w-8 h-8 rounded-full bg-gradient-to-br from-blue-400 to-blue-600
-    flex items-center justify-center text-white text-sm font-medium
+    w-[30px] h-[30px] rounded-full bg-black/10 dark:bg-white/15
+    flex items-center justify-center text-[13px] font-semibold
   `,
   headerTitle: `
-    text-[13px] font-medium text-neutral-800 dark:text-neutral-100
+    text-[13px] font-medium text-black dark:text-white
   `,
   headerSubtitle: `
-    text-[11px] text-neutral-500 dark:text-neutral-400
+    text-[11px] text-[#3c3c43]/60 dark:text-[#ebebf5]/60
   `,
   footer: `
-    px-2 py-2 border-t border-black/5 dark:border-white/5
-    flex items-center gap-2
+    px-[10px] pb-[8px] pt-[4px] flex items-center gap-2
   `,
   footerButton: `
-    p-1.5 rounded-md
-    text-neutral-500 dark:text-neutral-400
-    hover:bg-black/5 dark:hover:bg-white/5
-    hover:text-neutral-700 dark:hover:text-neutral-200
+    grid h-[28px] w-[28px] place-items-center rounded-[7px]
+    text-[#3c3c43]/70 dark:text-[#ebebf5]/70
+    hover:bg-black/5 dark:hover:bg-white/10
     transition-colors duration-150
   `
 };
@@ -8713,19 +9041,21 @@ function renderTahoeSidebar(data) {
     const itemClass = isSelected ? s.itemSelected : s.item;
     const iconClass = isSelected ? s.itemIconSelected : s.itemIcon;
     const badgeClass = isSelected ? s.itemBadgeSelected : s.itemBadge;
+    const hasChildren = (item.children?.length ?? 0) > 0;
+    const chevron = hasChildren ? `<span class='${s.disclosureChevron}${item.expanded ? " rotate-90" : ""}'>${icons.chevronRight}</span>` : "";
+    const tint = item.color ? ` style='color: ${item.color}'` : "";
     let html = `
-      <div class='${itemClass}' data-id='${item.id}' style='padding-left: ${8 + depth * 16}px'>
-        <span class='${iconClass}'>${getIcon2(item.icon || "document")}</span>
+      <div class='${itemClass}' data-id='${item.id}'${depth > 0 ? ` style='padding-left: ${4 + depth * 16}px'` : ""}>
+        <span class='${s.disclosure}'>${chevron}</span>
+        <span class='${s.itemIconSlot}'><span class='${iconClass}'${tint}>${getIcon2(item.icon || "document")}</span></span>
         <span class='${s.itemLabel}'>${item.label}</span>
         ${item.badge ? `<span class='${badgeClass}'>${item.badge}</span>` : ""}
       </div>
     `;
     if (item.children && item.expanded) {
-      html += `<div class='${s.children}'>`;
       item.children.forEach((child) => {
         html += renderItem(child, depth + 1);
       });
-      html += `</div>`;
     }
     return html;
   };
@@ -8734,8 +9064,8 @@ function renderTahoeSidebar(data) {
       <div class='${s.section}'>
         ${section.title ? `
           <div class="${section.collapsible ? s.sectionHeaderCollapsible : s.sectionHeader}" data-section="${section.id}">
-            ${section.collapsible ? `<span class="${s.collapseChevron}${section.collapsed ? "" : " rotate-90"}">${icons.chevronRight}</span>` : ""}
-            ${section.title}
+            <span class='truncate'>${section.title}</span>
+            ${section.collapsible ? `<span class='${s.collapseChevron}${section.collapsed ? " -rotate-90" : ""}'>${icons.chevronDown}</span>` : ""}
           </div>
         ` : ""}
         ${!section.collapsed ? section.items.map((item) => renderItem(item)).join("") : ""}
@@ -9475,7 +9805,7 @@ __export(exports_updater, {
 var import_fs3 = require("fs");
 var import_path2 = require("path");
 var import_child_process2 = require("child_process");
-var import_crypto2 = require("crypto");
+var import_crypto3 = require("crypto");
 var import_events3 = require("events");
 function findFirstByName(root, namePattern, kind) {
   const out = import_child_process2.execFileSync("find", [root, "-name", namePattern, "-type", kind, "-print0"]);
@@ -9492,6 +9822,12 @@ class AutoUpdater extends import_events3.EventEmitter {
   cachedEtag = null;
   cachedLastModified = null;
   cachedManifest = null;
+  emitError(error) {
+    if (this.listenerCount("error") > 0)
+      this.emit("error", error);
+    else
+      console.error("[Updater]", error);
+  }
   constructor(config) {
     super();
     const url = config.updateUrl;
@@ -9565,7 +9901,7 @@ class AutoUpdater extends import_events3.EventEmitter {
         return null;
       }
     } catch (error) {
-      this.emit("error", error);
+      this.emitError(error);
       return null;
     }
   }
@@ -9619,11 +9955,32 @@ class AutoUpdater extends import_events3.EventEmitter {
         this.emit("download-progress", progress);
       }
       fileStream.end();
+      await new Promise((resolve, reject) => {
+        fileStream.once("finish", resolve);
+        fileStream.once("error", reject);
+      });
       const hash = await this.computeFileHash(this.downloadPath);
       if (hash !== expectedHash) {
         import_fs3.unlinkSync(this.downloadPath);
         throw new Error("Download verification failed: hash mismatch");
       }
+      if (deltaUpdate) {
+        if (!import_fs3.statSync(this.config.appPath).isFile()) {
+          throw new Error("Delta updates require appPath to point to the installed bundle file");
+        }
+        const patchPath = this.downloadPath;
+        const reconstructedPath = import_path2.join(downloadDir, `reconstructed-${import_path2.basename(platformUpdate.url)}`);
+        await DeltaGenerator.apply(this.config.appPath, patchPath, reconstructedPath);
+        const reconstructedHash = await this.computeFileHash(reconstructedPath);
+        if (reconstructedHash !== platformUpdate.sha256) {
+          try {
+            import_fs3.unlinkSync(reconstructedPath);
+          } catch {}
+          throw new Error("Delta reconstruction failed: full bundle hash mismatch");
+        }
+        import_fs3.unlinkSync(patchPath);
+        this.downloadPath = reconstructedPath;
+      }
       if (this.config.publicKeyPem && !platformUpdate.signature) {
         import_fs3.unlinkSync(this.downloadPath);
         throw new Error("Updater: publicKeyPem is configured but the manifest entry has no signature. " + "Refusing to install unsigned update.");
@@ -9645,7 +10002,7 @@ class AutoUpdater extends import_events3.EventEmitter {
       }
       return this.downloadPath;
     } catch (error) {
-      this.emit("error", error);
+      this.emitError(error);
       return null;
     }
   }
@@ -9705,7 +10062,8 @@ class AutoUpdater extends import_events3.EventEmitter {
       }
     } catch (error) {
       progress.phase = "error";
-      this.emit("error", error);
+      this.emitError(error);
+      throw error;
     }
   }
   async installMacOSUpdate() {
@@ -9824,7 +10182,7 @@ class AutoUpdater extends import_events3.EventEmitter {
   }
   async computeFileHash(filePath) {
     return new Promise((resolve, reject) => {
-      const hash = import_crypto2.createHash("sha256");
+      const hash = import_crypto3.createHash("sha256");
       const stream = import_fs3.createReadStream(filePath);
       stream.on("data", (chunk) => hash.update(chunk));
       stream.on("end", () => resolve(hash.digest("hex")));
@@ -9896,7 +10254,7 @@ class DeltaGenerator {
   }
   static async computeHash(filePath) {
     return new Promise((resolve, reject) => {
-      const hash = import_crypto2.createHash("sha256");
+      const hash = import_crypto3.createHash("sha256");
       const stream = import_fs3.createReadStream(filePath);
       stream.on("data", (chunk) => hash.update(chunk));
       stream.on("end", () => resolve(hash.digest("hex")));
@@ -9915,7 +10273,7 @@ function generateUpdateManifest(options) {
     if (!info)
       continue;
     const bytes = import_fs3.readFileSync(info.path);
-    const hash = import_crypto2.createHash("sha256").update(bytes).digest("hex");
+    const hash = import_crypto3.createHash("sha256").update(bytes).digest("hex");
     manifest.platforms[platform] = {
       url: info.url,
       size: bytes.length,
@@ -9925,7 +10283,7 @@ function generateUpdateManifest(options) {
     const platformDeltas = options.deltas?.filter((d) => d.platform === platform) || [];
     for (const delta of platformDeltas) {
       const deltaBytes = import_fs3.readFileSync(delta.path);
-      const deltaHash = import_crypto2.createHash("sha256").update(deltaBytes).digest("hex");
+      const deltaHash = import_crypto3.createHash("sha256").update(deltaBytes).digest("hex");
       manifest.platforms[platform].delta.push({
         fromVersion: delta.fromVersion,
         url: delta.url,
@@ -10023,7 +10381,7 @@ var execFileAsync = import_node_util.promisify(import_node_child_process.execFil
 var versionMismatchWarned = false;
 function getSdkVersion() {
   try {
-    const pkgPath = import_node_path.join("/home/runner/work/craft/craft/packages/typescript/src", "..", "package.json");
+    const pkgPath = import_node_path.join("/Users/chris/Code/Tools/craft/packages/typescript/src", "..", "package.json");
     return JSON.parse(import_node_fs2.readFileSync(pkgPath, "utf-8")).version ?? "unknown";
   } catch {
     return "unknown";
@@ -10194,6 +10552,13 @@ class CraftApp {
       args.push("--menubar-only");
     if (window3?.titlebarHidden)
       args.push("--titlebar-hidden");
+    if (window3?.webSidebarMaterial) {
+      args.push("--web-sidebar-material");
+      if (window3?.webSidebarWidth)
+        args.push("--web-sidebar-width", String(window3.webSidebarWidth));
+      if (window3?.webSidebarMaterialOpacity !== undefined)
+        args.push("--web-sidebar-material-opacity", String(window3.webSidebarMaterialOpacity));
+    }
     if (window3?.icon)
       args.push("--icon", window3.icon);
     if (window3?.nativeSidebar) {
@@ -10209,7 +10574,7 @@ class CraftApp {
       } : undefined;
       if (sidebarConfig?.variant === "desktop") {
         sidebarConfig.material = sidebarConfig.material ?? "sidebar";
-        sidebarConfig.backgroundEffect = sidebarConfig.backgroundEffect ?? "shimmer";
+        sidebarConfig.backgroundEffect = sidebarConfig.backgroundEffect ?? "vibrancy";
         sidebarConfig.allowsVibrancy = sidebarConfig.allowsVibrancy ?? true;
       }
       if (sidebarConfig) {