app-builder-lib 27.0.0-alpha.4 → 27.0.0-alpha.6

package/dist/targets/win/nsis/progId.d.ts

@@ -0,0 +1,21 @@
+export declare const ELECTRON_BUILDER_NS_UUID: Buffer<ArrayBufferLike>;
+/**
+ * Builds Windows file-association ProgIDs that follow Microsoft's recommendations
+ * (https://learn.microsoft.com/windows/win32/com/-progid--key):
+ *   - at most 39 characters,
+ *   - only alphanumeric characters plus a single separating period,
+ *   - must not start with a digit.
+ *
+ * The result has the form `<program>.<component>`, where `<program>` is derived from the product
+ * filename (so it stays human-readable in the registry) and `<component>` mixes a readable prefix
+ * with a UUIDv5 derived from the app GUID. This keeps the ProgID unique across applications and
+ * stable for a given input, so the installer (register) and uninstaller (unregister) always agree.
+ */
+export declare class ProgIdMaker {
+    private readonly program;
+    private readonly namespace;
+    constructor(guid: string, productFilename: string);
+    progId(nameOrExt: string): string;
+    private static resolveProgram;
+}
+//# sourceMappingURL=progId.d.ts.map

package/dist/targets/win/nsis/progId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"progId.d.ts","sourceRoot":"","sources":["../../../../src/targets/win/nsis/progId.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,wBAAwB,yBAAqD,CAAA;AAiB1F;;;;;;;;;;;GAWG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAQ;IAChC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAQ;gBAEtB,IAAI,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM;IASjD,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAQjC,OAAO,CAAC,MAAM,CAAC,cAAc;CAa9B"}

package/dist/targets/win/nsis/progId.js

@@ -0,0 +1,60 @@
+import { UUID } from "builder-util-runtime";
+// noinspection SpellCheckingInspection
+export const ELECTRON_BUILDER_NS_UUID = UUID.parse("50e065bc-3134-11e6-9bab-38c9862bdaf3");
+// Microsoft caps a ProgID at 39 characters.
+const MAX_PROG_ID_LENGTH = 39;
+// Budget for the human-readable head (program + "." + component prefix); the rest is reserved for the
+// UUID tail so that some entropy always survives the final truncation.
+const MAX_READABLE_LENGTH = 31;
+// Cap on the readable program segment, leaving room for the component to carry entropy.
+const MAX_PROGRAM_LENGTH = 19;
+// A product filename that sanitizes shorter than this is too short to be a useful program segment.
+const MIN_PROGRAM_LENGTH = 6;
+// ProgIDs may only contain alphanumerics plus a single separating period, so drop everything else.
+function sanitize(value) {
+    return value.replace(/[^A-Za-z0-9]/g, "");
+}
+/**
+ * Builds Windows file-association ProgIDs that follow Microsoft's recommendations
+ * (https://learn.microsoft.com/windows/win32/com/-progid--key):
+ *   - at most 39 characters,
+ *   - only alphanumeric characters plus a single separating period,
+ *   - must not start with a digit.
+ *
+ * The result has the form `<program>.<component>`, where `<program>` is derived from the product
+ * filename (so it stays human-readable in the registry) and `<component>` mixes a readable prefix
+ * with a UUIDv5 derived from the app GUID. This keeps the ProgID unique across applications and
+ * stable for a given input, so the installer (register) and uninstaller (unregister) always agree.
+ */
+export class ProgIdMaker {
+    constructor(guid, productFilename) {
+        // `guid` may be any user-supplied string (including a non-UUID), so normalize it to a real UUID.
+        // It is lowercased because UUID.parse only understands lowercase hex; an uppercase GUID would
+        // otherwise be parsed into a corrupt namespace and collide across applications.
+        const uuidString = (UUID.check(guid) ? guid : UUID.v5(guid, ELECTRON_BUILDER_NS_UUID)).toLowerCase();
+        this.namespace = UUID.parse(uuidString);
+        this.program = ProgIdMaker.resolveProgram(guid, productFilename, uuidString);
+    }
+    progId(nameOrExt) {
+        const componentPrefix = sanitize(nameOrExt).slice(0, MAX_READABLE_LENGTH - this.program.length);
+        const componentUuid = sanitize(UUID.v5(nameOrExt, this.namespace));
+        return `${this.program}.${componentPrefix}${componentUuid}`.slice(0, MAX_PROG_ID_LENGTH);
+    }
+    // Resolves the readable program segment, preferring the product filename and falling back to the
+    // GUID so the result is always non-empty and never starts with a digit (both Microsoft requirements).
+    static resolveProgram(guid, productFilename, uuidString) {
+        let program = sanitize(productFilename);
+        if (program.length < MIN_PROGRAM_LENGTH) {
+            program = sanitize(guid);
+        }
+        if (program.length < MIN_PROGRAM_LENGTH) {
+            // `App<uuid>` is guaranteed long enough and starts with a letter.
+            program = sanitize(`App${uuidString}`);
+        }
+        else if (/^\d/.test(program)) {
+            program = `App${program}`;
+        }
+        return program.slice(0, MAX_PROGRAM_LENGTH);
+    }
+}
+//# sourceMappingURL=progId.js.map

package/dist/targets/win/nsis/progId.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"progId.js","sourceRoot":"","sources":["../../../../src/targets/win/nsis/progId.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAA;AAE3C,uCAAuC;AACvC,MAAM,CAAC,MAAM,wBAAwB,GAAG,IAAI,CAAC,KAAK,CAAC,sCAAsC,CAAC,CAAA;AAE1F,4CAA4C;AAC5C,MAAM,kBAAkB,GAAG,EAAE,CAAA;AAC7B,sGAAsG;AACtG,uEAAuE;AACvE,MAAM,mBAAmB,GAAG,EAAE,CAAA;AAC9B,wFAAwF;AACxF,MAAM,kBAAkB,GAAG,EAAE,CAAA;AAC7B,mGAAmG;AACnG,MAAM,kBAAkB,GAAG,CAAC,CAAA;AAE5B,mGAAmG;AACnG,SAAS,QAAQ,CAAC,KAAa;IAC7B,OAAO,KAAK,CAAC,OAAO,CAAC,eAAe,EAAE,EAAE,CAAC,CAAA;AAC3C,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,OAAO,WAAW;IAItB,YAAY,IAAY,EAAE,eAAuB;QAC/C,iGAAiG;QACjG,8FAA8F;QAC9F,gFAAgF;QAChF,MAAM,UAAU,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,wBAAwB,CAAC,CAAC,CAAC,WAAW,EAAE,CAAA;QACpG,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAA;QACvC,IAAI,CAAC,OAAO,GAAG,WAAW,CAAC,cAAc,CAAC,IAAI,EAAE,eAAe,EAAE,UAAU,CAAC,CAAA;IAC9E,CAAC;IAED,MAAM,CAAC,SAAiB;QACtB,MAAM,eAAe,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,mBAAmB,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAA;QAC/F,MAAM,aAAa,GAAG,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,CAAA;QAClE,OAAO,GAAG,IAAI,CAAC,OAAO,IAAI,eAAe,GAAG,aAAa,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,kBAAkB,CAAC,CAAA;IAC1F,CAAC;IAED,iGAAiG;IACjG,sGAAsG;IAC9F,MAAM,CAAC,cAAc,CAAC,IAAY,EAAE,eAAuB,EAAE,UAAkB;QACrF,IAAI,OAAO,GAAG,QAAQ,CAAC,eAAe,CAAC,CAAA;QACvC,IAAI,OAAO,CAAC,MAAM,GAAG,kBAAkB,EAAE,CAAC;YACxC,OAAO,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAA;QAC1B,CAAC;QACD,IAAI,OAAO,CAAC,MAAM,GAAG,kBAAkB,EAAE,CAAC;YACxC,kEAAkE;YAClE,OAAO,GAAG,QAAQ,CAAC,MAAM,UAAU,EAAE,CAAC,CAAA;QACxC,CAAC;aAAM,IAAI,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;YAC/B,OAAO,GAAG,MAAM,OAAO,EAAE,CAAA;QAC3B,CAAC;QACD,OAAO,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,kBAAkB,CAAC,CAAA;IAC7C,CAAC;CACF","sourcesContent":["import { UUID } from \"builder-util-runtime\"\n\n// noinspection SpellCheckingInspection\nexport const ELECTRON_BUILDER_NS_UUID = UUID.parse(\"50e065bc-3134-11e6-9bab-38c9862bdaf3\")\n\n// Microsoft caps a ProgID at 39 characters.\nconst MAX_PROG_ID_LENGTH = 39\n// Budget for the human-readable head (program + \".\" + component prefix); the rest is reserved for the\n// UUID tail so that some entropy always survives the final truncation.\nconst MAX_READABLE_LENGTH = 31\n// Cap on the readable program segment, leaving room for the component to carry entropy.\nconst MAX_PROGRAM_LENGTH = 19\n// A product filename that sanitizes shorter than this is too short to be a useful program segment.\nconst MIN_PROGRAM_LENGTH = 6\n\n// ProgIDs may only contain alphanumerics plus a single separating period, so drop everything else.\nfunction sanitize(value: string): string {\n  return value.replace(/[^A-Za-z0-9]/g, \"\")\n}\n\n/**\n * Builds Windows file-association ProgIDs that follow Microsoft's recommendations\n * (https://learn.microsoft.com/windows/win32/com/-progid--key):\n *   - at most 39 characters,\n *   - only alphanumeric characters plus a single separating period,\n *   - must not start with a digit.\n *\n * The result has the form `<program>.<component>`, where `<program>` is derived from the product\n * filename (so it stays human-readable in the registry) and `<component>` mixes a readable prefix\n * with a UUIDv5 derived from the app GUID. This keeps the ProgID unique across applications and\n * stable for a given input, so the installer (register) and uninstaller (unregister) always agree.\n */\nexport class ProgIdMaker {\n  private readonly program: string\n  private readonly namespace: Buffer\n\n  constructor(guid: string, productFilename: string) {\n    // `guid` may be any user-supplied string (including a non-UUID), so normalize it to a real UUID.\n    // It is lowercased because UUID.parse only understands lowercase hex; an uppercase GUID would\n    // otherwise be parsed into a corrupt namespace and collide across applications.\n    const uuidString = (UUID.check(guid) ? guid : UUID.v5(guid, ELECTRON_BUILDER_NS_UUID)).toLowerCase()\n    this.namespace = UUID.parse(uuidString)\n    this.program = ProgIdMaker.resolveProgram(guid, productFilename, uuidString)\n  }\n\n  progId(nameOrExt: string): string {\n    const componentPrefix = sanitize(nameOrExt).slice(0, MAX_READABLE_LENGTH - this.program.length)\n    const componentUuid = sanitize(UUID.v5(nameOrExt, this.namespace))\n    return `${this.program}.${componentPrefix}${componentUuid}`.slice(0, MAX_PROG_ID_LENGTH)\n  }\n\n  // Resolves the readable program segment, preferring the product filename and falling back to the\n  // GUID so the result is always non-empty and never starts with a digit (both Microsoft requirements).\n  private static resolveProgram(guid: string, productFilename: string, uuidString: string): string {\n    let program = sanitize(productFilename)\n    if (program.length < MIN_PROGRAM_LENGTH) {\n      program = sanitize(guid)\n    }\n    if (program.length < MIN_PROGRAM_LENGTH) {\n      // `App<uuid>` is guaranteed long enough and starts with a letter.\n      program = sanitize(`App${uuidString}`)\n    } else if (/^\\d/.test(program)) {\n      program = `App${program}`\n    }\n    return program.slice(0, MAX_PROGRAM_LENGTH)\n  }\n}\n"]}

package/dist/targets/win/winAppUtil.d.ts

@@ -0,0 +1,115 @@
+import { Arch, escapeForXml } from "builder-util";
+import type { MsixWindowsService } from "../../options/MsixOptions.js";
+import { Nullish } from "builder-util-runtime";
+import type { Target, TargetSpecificOptions } from "../../core.js";
+import { FileAssociation } from "../../options/FileAssociation.js";
+import { Protocol } from "../../options/PlatformSpecificBuildOptions.js";
+import { VmManager } from "../../vm/vm.js";
+import type { WinPackager } from "../../winPackager.js";
+export declare const APPX_ASSETS_DIR_NAME = "appx";
+/**
+ * Escapes a string for safe use as an XML attribute value (double- or single-quoted) or element text.
+ * Aliased to builder-util's {@link escapeForXml} so the Appx/MSIX manifest path shares the single
+ * consolidated escaper (PR #9853) and cannot drift from it.
+ */
+export declare const escapeXmlAttr: typeof escapeForXml;
+/**
+ * Manifest macros whose substituted values are raw user/config text and therefore must be
+ * XML-escaped before being placed into the (Appx/MSIX) manifest. Every other macro either
+ * returns a prebuilt XML fragment (capabilities, extensions, lockScreen, defaultTile,
+ * splashScreen, resourceLanguages, packageIntegrity) or a validated/constant value
+ * (version, applicationId, identityName, arch, logo, square*Logo) and must NOT be escaped.
+ *
+ * Note: `publisher` is emitted inside a single-quoted attribute (`Publisher='...'`). escapeForXml
+ * escapes `& < > " '` — apostrophes become `&apos;`, which is valid inside the single-quoted
+ * attribute, so a `'` in a certificate Subject is handled correctly.
+ */
+export declare const RAW_TEXT_MANIFEST_MACROS: ReadonlySet<string>;
+/**
+ * Substitutes `${macro}` placeholders in an Appx/MSIX manifest template. `resolve` returns the
+ * RAW value for a macro; values for macros in {@link RAW_TEXT_MANIFEST_MACROS} are XML-escaped
+ * here so individual call sites cannot forget to. `resolve` may throw for unknown macros.
+ */
+export declare function substituteManifestMacros(template: string, resolve: (macro: string) => string): string;
+export declare const DEFAULT_RESOURCE_LANG = "en-US";
+export declare const vendorAssetsForDefaultAssets: Record<string, string>;
+export declare const restrictedApplicationIdValues: string[];
+export declare function computeUserAssets(vm: VmManager, vendorPath: string, userAssetDir: string | null): Promise<{
+    userAssets: string[];
+    mappings: string[];
+    allAssets: string[];
+}>;
+/**
+ * The makeappx mapping file (`/f`) is a quote-delimited, newline-separated `[Files]` list with NO escape
+ * mechanism. A path component containing a double-quote or CR/LF would corrupt the format or inject an
+ * extra mapping entry (remapping/shadowing files in the produced package), so such paths are rejected.
+ */
+export declare function assertSafeMappingPath(value: string, kind: string): void;
+/**
+ * Builds the `[Files]` mapping lines for the packaged app payload (`"<vm source>" "app\<rel>"`), shared
+ * by the AppX and MSIX targets. Each relative path is validated via {@link assertSafeMappingPath}.
+ */
+export declare function buildAppFileMappings(vm: VmManager, appOutDir: string): Promise<Array<string>>;
+export declare function validateApplicationId(result: string, contextLabel: string): void;
+export declare function validateIdentityName(result: string, contextLabel: string): void;
+export declare function resourceLanguageTag(userLanguages: Array<string> | Nullish): string;
+export declare function lockScreenTag(userAssets: Array<string>): string;
+export declare function defaultTileTag(userAssets: Array<string>, showNameOnTiles: boolean): string;
+export declare function splashScreenTag(userAssets: Array<string>): string;
+export declare function isDefaultAssetIncluded(userAssets: Array<string>, defaultAsset: string): boolean;
+export declare function isScaledAssetsProvided(userAssets: Array<string>): boolean;
+/**
+ * Resolves the final applicationId value from config, stripping any leading numeric prefix
+ * from identityName (a common user mistake), then validates it.
+ */
+export declare function resolvePackageApplicationId(applicationId: string | undefined, identityName: string | null | undefined, appName: string, contextLabel: string): string;
+export declare function resolvePackageIdentityName(identityName: string | null | undefined, appName: string, contextLabel: string): string;
+export declare function buildCapabilitiesXml(capabilityNames: Array<string> | null | undefined): string;
+export interface ExtensionsInput {
+    protocols: Array<Protocol>;
+    fileAssociations: Array<FileAssociation>;
+    addAutoLaunchExtension?: boolean;
+    customExtensionsPath?: string;
+    appDir: string;
+    executable: string;
+    displayName: string;
+    dependencyNames?: Record<string, string> | null;
+}
+export declare function buildExtensionsXml(input: ExtensionsInput): Promise<string>;
+export declare function buildWindowsServicesXml(services: ReadonlyArray<MsixWindowsService> | undefined, defaultExecutable: string): string;
+/** Options shared by the AppX and MSIX targets that the build pipeline reads directly. */
+export interface AppxPackageBuildOptions extends TargetSpecificOptions {
+    readonly publisher?: string | null;
+    readonly makeappxArgs?: Array<string> | null;
+    readonly electronUpdaterAware?: boolean;
+}
+export interface AppxBuildContext {
+    readonly arch: Arch;
+    readonly artifactPath: string;
+    readonly vendorPathKit: string;
+    readonly vm: VmManager;
+}
+export interface AppxPackageBuildConfig {
+    /** `"appx"` | `"msix"` — drives artifact naming, the safe-artifact name, and the debug-log key. */
+    readonly kind: "appx" | "msix";
+    /** Human-facing target name for build-progress events (`"AppX"` | `"MSIX"`). */
+    readonly presentableName: string;
+    /** Writes the target-specific `AppxManifest.xml` (AppX and MSIX use different templates/macros). */
+    writeManifest(manifestFile: string, arch: Arch, publisher: string, userAssets: Array<string>): Promise<void>;
+    /** Optional pre-flight validation (e.g. the MSIX legacy-toolset guard); a throw aborts the build. */
+    preflight?(): void | Promise<void>;
+    /**
+     * Optional hook invoked synchronously (before the deferred pack task is queued) with the build
+     * context. MSIX uses it to record the per-arch artifact + VM/kit paths so `finishBuild` can assemble
+     * the `.msixbundle` / `.msixupload`.
+     */
+    onBuilt?(ctx: AppxBuildContext): void;
+}
+/**
+ * Shared build pipeline for the AppX and MSIX targets — both pack via the Windows Kits `makeappx.exe`
+ * and differ only in the bits supplied through {@link AppxPackageBuildConfig}. It walks the app payload
+ * and assets into a `makeappx` mapping file, generates `resources.pri` when scaled assets are present,
+ * writes the manifest, then packs + signs the artifact on the target's build queue.
+ */
+export declare function buildAppxPackage(target: Target, packager: WinPackager, options: AppxPackageBuildOptions, appOutDir: string, arch: Arch, config: AppxPackageBuildConfig): Promise<void>;
+//# sourceMappingURL=winAppUtil.d.ts.map

package/dist/targets/win/winAppUtil.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"winAppUtil.d.ts","sourceRoot":"","sources":["../../../src/targets/win/winAppUtil.ts"],"names":[],"mappings":"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"}

package/dist/targets/win/winAppUtil.js

@@ -0,0 +1,407 @@
+import { asArray, copyOrLinkFile, ensureNotBusy, escapeForXml, InvalidConfigurationError, log, sanitizeDirPath, walk } from "builder-util";
+import _fsExtra from "fs-extra";
+const { emptyDir, readdir, readFile, writeFile } = _fsExtra;
+import * as path from "path";
+import { getWindowsKitsBundle } from "../../toolsets/winCodeSign.js";
+import { getTemplatePath } from "../../util/pathManager.js";
+import { createStageDir } from "../targetUtil.js";
+import { CAPABILITIES, isValidCapabilityName } from "./AppxCapabilities.js";
+export const APPX_ASSETS_DIR_NAME = "appx";
+/**
+ * Escapes a string for safe use as an XML attribute value (double- or single-quoted) or element text.
+ * Aliased to builder-util's {@link escapeForXml} so the Appx/MSIX manifest path shares the single
+ * consolidated escaper (PR #9853) and cannot drift from it.
+ */
+export const escapeXmlAttr = escapeForXml;
+/**
+ * Manifest macros whose substituted values are raw user/config text and therefore must be
+ * XML-escaped before being placed into the (Appx/MSIX) manifest. Every other macro either
+ * returns a prebuilt XML fragment (capabilities, extensions, lockScreen, defaultTile,
+ * splashScreen, resourceLanguages, packageIntegrity) or a validated/constant value
+ * (version, applicationId, identityName, arch, logo, square*Logo) and must NOT be escaped.
+ *
+ * Note: `publisher` is emitted inside a single-quoted attribute (`Publisher='...'`). escapeForXml
+ * escapes `& < > " '` — apostrophes become `&apos;`, which is valid inside the single-quoted
+ * attribute, so a `'` in a certificate Subject is handled correctly.
+ */
+export const RAW_TEXT_MANIFEST_MACROS = new Set([
+    "publisher",
+    "publisherDisplayName",
+    "executable",
+    "displayName",
+    "description",
+    "backgroundColor",
+    "minVersion",
+    "maxVersionTested",
+]);
+/**
+ * Substitutes `${macro}` placeholders in an Appx/MSIX manifest template. `resolve` returns the
+ * RAW value for a macro; values for macros in {@link RAW_TEXT_MANIFEST_MACROS} are XML-escaped
+ * here so individual call sites cannot forget to. `resolve` may throw for unknown macros.
+ */
+export function substituteManifestMacros(template, resolve) {
+    return template.replace(/\${([a-zA-Z0-9]+)}/g, (_match, macro) => {
+        const value = resolve(macro);
+        return RAW_TEXT_MANIFEST_MACROS.has(macro) ? escapeXmlAttr(value) : value;
+    });
+}
+export const DEFAULT_RESOURCE_LANG = "en-US";
+export const vendorAssetsForDefaultAssets = {
+    "StoreLogo.png": "SampleAppx.50x50.png",
+    "Square150x150Logo.png": "SampleAppx.150x150.png",
+    "Square44x44Logo.png": "SampleAppx.44x44.png",
+    "Wide310x150Logo.png": "SampleAppx.310x150.png",
+};
+export const restrictedApplicationIdValues = [
+    "CON",
+    "PRN",
+    "AUX",
+    "NUL",
+    "COM1",
+    "COM2",
+    "COM3",
+    "COM4",
+    "COM5",
+    "COM6",
+    "COM7",
+    "COM8",
+    "COM9",
+    "LPT1",
+    "LPT2",
+    "LPT3",
+    "LPT4",
+    "LPT5",
+    "LPT6",
+    "LPT7",
+    "LPT8",
+    "LPT9",
+];
+export async function computeUserAssets(vm, vendorPath, userAssetDir) {
+    const mappings = [];
+    let userAssets;
+    const allAssets = [];
+    if (userAssetDir == null) {
+        userAssets = [];
+    }
+    else {
+        userAssets = (await readdir(userAssetDir)).filter(it => !it.startsWith(".") && !it.endsWith(".db") && it.includes("."));
+        for (const name of userAssets) {
+            // The makeappx mapping file is quote-delimited with no escape mechanism; reject names that would corrupt it / inject extra entries.
+            assertSafeMappingPath(name, "Asset file name");
+            mappings.push(`"${vm.toVmFile(userAssetDir)}${vm.pathSep}${name}" "assets\\${name}"`);
+            allAssets.push(path.join(userAssetDir, name));
+        }
+    }
+    for (const defaultAsset of Object.keys(vendorAssetsForDefaultAssets)) {
+        if (userAssets.length === 0 || !isDefaultAssetIncluded(userAssets, defaultAsset)) {
+            // codeql[js/shell-command-constructed-from-input] - vendorPath is a trusted toolset bundle dir and the asset name is a hardcoded constant; the joined path is resolved and contained under vendorPath via sanitizeDirPath, and only reaches makeappx as an execFile argv element (array args, no shell)
+            const file = sanitizeDirPath(path.join(vendorPath, "appxAssets", vendorAssetsForDefaultAssets[defaultAsset]), vendorPath);
+            mappings.push(`"${vm.toVmFile(file)}" "assets\\${defaultAsset}"`);
+            allAssets.push(file);
+        }
+    }
+    return { userAssets, mappings, allAssets };
+}
+/**
+ * The makeappx mapping file (`/f`) is a quote-delimited, newline-separated `[Files]` list with NO escape
+ * mechanism. A path component containing a double-quote or CR/LF would corrupt the format or inject an
+ * extra mapping entry (remapping/shadowing files in the produced package), so such paths are rejected.
+ */
+export function assertSafeMappingPath(value, kind) {
+    if (/["\r\n]/.test(value)) {
+        throw new InvalidConfigurationError(`${kind} cannot contain a double-quote or newline — the makeappx mapping file cannot represent it: ${JSON.stringify(value)}`);
+    }
+}
+/**
+ * Builds the `[Files]` mapping lines for the packaged app payload (`"<vm source>" "app\<rel>"`), shared
+ * by the AppX and MSIX targets. Each relative path is validated via {@link assertSafeMappingPath}.
+ */
+export async function buildAppFileMappings(vm, appOutDir) {
+    return Promise.all((await walk(appOutDir)).map(file => {
+        let relPath = file.substring(appOutDir.length + 1);
+        if (path.sep !== "\\") {
+            relPath = relPath.replace(/\//g, "\\");
+        }
+        assertSafeMappingPath(relPath, "Packaged file path");
+        return `"${vm.toVmFile(file)}" "app\\${relPath}"`;
+    }));
+}
+export function validateApplicationId(result, contextLabel) {
+    const validCharactersRegex = /^([A-Za-z][A-Za-z0-9]*)(\.[A-Za-z][A-Za-z0-9]*)*$/;
+    if (result.length < 1 || result.length > 64) {
+        throw new InvalidConfigurationError(`${contextLabel} Application.Id must be between 1 and 64 characters in length: ${result}`);
+    }
+    if (!validCharactersRegex.test(result)) {
+        throw new InvalidConfigurationError(`${contextLabel} Application.Id must contain only alpha-numeric characters separated by periods, where each segment starts with an alphabetic character: ${result}`);
+    }
+    if (restrictedApplicationIdValues.includes(result.toUpperCase())) {
+        throw new InvalidConfigurationError(`${contextLabel} Application.Id cannot contain restricted values ${JSON.stringify(restrictedApplicationIdValues)}: ${result}`);
+    }
+}
+export function validateIdentityName(result, contextLabel) {
+    const validCharactersRegex = /^[a-zA-Z0-9.-]+$/;
+    if (result.length < 3 || result.length > 50) {
+        throw new InvalidConfigurationError(`${contextLabel} identityName must be between 3 and 50 characters in length: ${result}`);
+    }
+    if (!validCharactersRegex.test(result)) {
+        throw new InvalidConfigurationError(`${contextLabel} identityName must contain only alpha-numeric, period, and dash characters: ${result}`);
+    }
+    if (restrictedApplicationIdValues.includes(result.toUpperCase())) {
+        throw new InvalidConfigurationError(`${contextLabel} identityName cannot contain restricted values ${JSON.stringify(restrictedApplicationIdValues)}: ${result}`);
+    }
+}
+export function resourceLanguageTag(userLanguages) {
+    if (userLanguages == null || userLanguages.length === 0) {
+        userLanguages = [DEFAULT_RESOURCE_LANG];
+    }
+    return userLanguages.map(it => `<Resource Language="${escapeXmlAttr(it.trim().replace(/_/g, "-"))}" />`).join("\n");
+}
+export function lockScreenTag(userAssets) {
+    if (isDefaultAssetIncluded(userAssets, "BadgeLogo.png")) {
+        return '<uap:LockScreen Notification="badgeAndTileText" BadgeLogo="assets\\BadgeLogo.png" />';
+    }
+    return "";
+}
+export function defaultTileTag(userAssets, showNameOnTiles) {
+    const defaultTiles = ["<uap:DefaultTile", 'Wide310x150Logo="assets\\Wide310x150Logo.png"'];
+    if (isDefaultAssetIncluded(userAssets, "LargeTile.png")) {
+        defaultTiles.push('Square310x310Logo="assets\\LargeTile.png"');
+    }
+    if (isDefaultAssetIncluded(userAssets, "SmallTile.png")) {
+        defaultTiles.push('Square71x71Logo="assets\\SmallTile.png"');
+    }
+    if (showNameOnTiles) {
+        defaultTiles.push(">");
+        defaultTiles.push("<uap:ShowNameOnTiles>");
+        defaultTiles.push("<uap:ShowOn", 'Tile="wide310x150Logo"', "/>");
+        defaultTiles.push("<uap:ShowOn", 'Tile="square150x150Logo"', "/>");
+        defaultTiles.push("</uap:ShowNameOnTiles>");
+        defaultTiles.push("</uap:DefaultTile>");
+    }
+    else {
+        defaultTiles.push("/>");
+    }
+    return defaultTiles.join(" ");
+}
+export function splashScreenTag(userAssets) {
+    if (isDefaultAssetIncluded(userAssets, "SplashScreen.png")) {
+        return '<uap:SplashScreen Image="assets\\SplashScreen.png" />';
+    }
+    return "";
+}
+export function isDefaultAssetIncluded(userAssets, defaultAsset) {
+    const defaultAssetName = defaultAsset.substring(0, defaultAsset.indexOf("."));
+    return userAssets.some(it => it.includes(defaultAssetName));
+}
+export function isScaledAssetsProvided(userAssets) {
+    return userAssets.some(it => it.includes(".scale-") || it.includes(".targetsize-"));
+}
+/**
+ * Resolves the final applicationId value from config, stripping any leading numeric prefix
+ * from identityName (a common user mistake), then validates it.
+ */
+export function resolvePackageApplicationId(applicationId, identityName, appName, contextLabel) {
+    let result;
+    const identitynumber = parseInt(identityName, 10) || NaN;
+    if (applicationId) {
+        result = applicationId;
+        validateApplicationId(result, contextLabel);
+        return result;
+    }
+    if (!isNaN(identitynumber) && identityName !== null && identityName !== undefined) {
+        if (identityName[0] === "0") {
+            log.warn(`Remove the 0${identitynumber}`);
+            result = identityName.replace("0" + identitynumber.toString(), "");
+        }
+        else {
+            log.warn(`Remove the ${identitynumber}`);
+            result = identityName.replace(identitynumber.toString(), "");
+        }
+    }
+    else {
+        result = identityName || appName;
+    }
+    // `result` is a derived value (from identityName or the app name). identityName allows characters
+    // (e.g. a dash) that are invalid in an Application.Id, so surface an actionable error rather than
+    // the raw low-level validation message when the derivation cannot produce a valid id.
+    try {
+        validateApplicationId(result, contextLabel);
+    }
+    catch (e) {
+        throw new InvalidConfigurationError(`${contextLabel} could not derive a valid Application.Id ("${result}") from identityName/name — Application.Id allows only alpha-numeric segments separated by periods (no dashes). Set the "applicationId" option explicitly. Cause: ${e.message}`);
+    }
+    return result;
+}
+export function resolvePackageIdentityName(identityName, appName, contextLabel) {
+    const result = identityName || appName;
+    validateIdentityName(result, contextLabel);
+    return result;
+}
+export function buildCapabilitiesXml(capabilityNames) {
+    const caps = asArray(capabilityNames);
+    const capSet = new Set(caps);
+    const invalid = Array.from(capSet).filter(cap => !isValidCapabilityName(cap));
+    if (invalid.length > 0) {
+        throw new Error(`invalid windows capabilit${invalid.length === 1 ? "y" : "ies"} specified: ${invalid.join(", ")}`);
+    }
+    capSet.add("runFullTrust");
+    const capabilityStrings = CAPABILITIES.filter(cap => capSet.has(cap.name)).map(cap => `  ${cap.toXMLString()}`);
+    return capabilityStrings.join("\n");
+}
+export async function buildExtensionsXml(input) {
+    const { protocols, fileAssociations, appDir, executable, displayName, customExtensionsPath } = input;
+    let isAddAutoLaunch = input.addAutoLaunchExtension;
+    if (isAddAutoLaunch === undefined) {
+        isAddAutoLaunch = input.dependencyNames != null && input.dependencyNames["electron-winstore-auto-launch"] != null;
+    }
+    if (!isAddAutoLaunch && protocols.length === 0 && fileAssociations.length === 0 && customExtensionsPath === undefined) {
+        return "";
+    }
+    let extensions = "<Extensions>";
+    if (isAddAutoLaunch) {
+        extensions += `
+        <desktop:Extension Category="windows.startupTask" Executable="${escapeXmlAttr(executable)}" EntryPoint="Windows.FullTrustApplication">
+          <desktop:StartupTask TaskId="SlackStartup" Enabled="true" DisplayName="${escapeXmlAttr(displayName)}" />
+        </desktop:Extension>`;
+    }
+    for (const protocol of protocols) {
+        for (const scheme of asArray(protocol.schemes)) {
+            extensions += `
+          <uap:Extension Category="windows.protocol">
+            <uap:Protocol Name="${escapeXmlAttr(scheme)}">
+               <uap:DisplayName>${escapeXmlAttr(protocol.name)}</uap:DisplayName>
+             </uap:Protocol>
+          </uap:Extension>`;
+        }
+    }
+    for (const fileAssociation of fileAssociations) {
+        for (const ext of asArray(fileAssociation.ext)) {
+            const extEsc = escapeXmlAttr(ext);
+            extensions += `
+          <uap:Extension Category="windows.fileTypeAssociation">
+            <uap:FileTypeAssociation Name="${extEsc}">
+              <uap:SupportedFileTypes>
+                <uap:FileType>.${extEsc}</uap:FileType>
+              </uap:SupportedFileTypes>
+            </uap:FileTypeAssociation>
+          </uap:Extension>`;
+        }
+    }
+    if (customExtensionsPath !== undefined) {
+        const extensionsPath = path.resolve(appDir, customExtensionsPath);
+        extensions += await readFile(extensionsPath, "utf8");
+    }
+    extensions += "</Extensions>";
+    return extensions;
+}
+export function buildWindowsServicesXml(services, defaultExecutable) {
+    if (!services || services.length === 0) {
+        return "";
+    }
+    return services
+        .map(svc => {
+        const exe = escapeXmlAttr(svc.executable || defaultExecutable);
+        // desktop6:Service requires both StartupType ("auto" | "manual" | "disabled") and StartAccount
+        // ("localSystem" | "localService" | "networkService"). Omitting StartAccount produces a manifest
+        // makeappx rejects. See https://learn.microsoft.com/uwp/schemas/appxpackage/uapmanifestschema/element-desktop6-service
+        const startupType = escapeXmlAttr(svc.startupType ?? "manual");
+        const startAccount = escapeXmlAttr(svc.startAccount ?? "localSystem");
+        const argsAttr = svc.arguments != null ? ` Arguments="${escapeXmlAttr(svc.arguments)}"` : "";
+        return `
+        <desktop6:Extension Category="windows.service" Executable="${exe}" EntryPoint="Windows.FullTrustApplication">
+          <desktop6:Service Name="${escapeXmlAttr(svc.name)}" StartupType="${startupType}" StartAccount="${startAccount}"${argsAttr} />
+        </desktop6:Extension>`;
+    })
+        .join("");
+}
+/**
+ * Shared build pipeline for the AppX and MSIX targets — both pack via the Windows Kits `makeappx.exe`
+ * and differ only in the bits supplied through {@link AppxPackageBuildConfig}. It walks the app payload
+ * and assets into a `makeappx` mapping file, generates `resources.pri` when scaled assets are present,
+ * writes the manifest, then packs + signs the artifact on the target's build queue.
+ */
+export async function buildAppxPackage(target, packager, options, appOutDir, arch, config) {
+    await config.preflight?.();
+    const artifactName = packager.expandArtifactBeautyNamePattern(options, config.kind, arch);
+    const artifactPath = path.join(target.outDir, artifactName);
+    await packager.emitArtifactBuildStarted({ targetPresentableName: config.presentableName, file: artifactPath, arch });
+    const vendorPath = await getWindowsKitsBundle({ winCodeSign: packager.config.toolsets?.winCodeSign, resourcesDir: packager.buildResourcesDir });
+    const vm = await packager.vm.value;
+    config.onBuilt?.({ arch, artifactPath, vendorPathKit: vendorPath.kit, vm });
+    const stageDir = await createStageDir(target, packager, arch);
+    const mappingFile = stageDir.getTempFile("mapping.txt");
+    const makeAppXArgs = ["pack", "/o" /* overwrite the output file if it exists */, "/f", vm.toVmFile(mappingFile), "/p", vm.toVmFile(artifactPath)];
+    if (packager.compression === "store") {
+        makeAppXArgs.push("/nc");
+    }
+    const mappingList = [];
+    mappingList.push(await buildAppFileMappings(vm, appOutDir));
+    const userAssetDir = await packager.getResource(undefined, APPX_ASSETS_DIR_NAME);
+    const assetInfo = await computeUserAssets(vm, vendorPath.appxAssets, userAssetDir);
+    const userAssets = assetInfo.userAssets;
+    const manifestFile = stageDir.getTempFile("AppxManifest.xml");
+    // https://github.com/electron-userland/electron-builder/issues/2108#issuecomment-333200711
+    const publisher = await (await packager.signingManager.value).computePublisherName(target, options.publisher ?? null);
+    await config.writeManifest(manifestFile, arch, publisher, userAssets);
+    await packager.emitAppxManifestCreated(manifestFile);
+    mappingList.push(assetInfo.mappings);
+    mappingList.push([`"${vm.toVmFile(manifestFile)}" "AppxManifest.xml"`]);
+    if (isScaledAssetsProvided(userAssets)) {
+        const outFile = vm.toVmFile(stageDir.getTempFile("resources.pri"));
+        const makePriExe = path.join(vendorPath.kit, "makepri.exe");
+        const makePriPath = vm.toVmFile(makePriExe);
+        const assetRoot = stageDir.getTempFile("appx/assets");
+        await emptyDir(assetRoot);
+        await Promise.all(assetInfo.allAssets.map(it => copyOrLinkFile(it, path.join(assetRoot, path.basename(it)))));
+        // Wait out any transient AV/share lock on the freshly-extracted kit binary (see ensureNotBusy).
+        await ensureNotBusy(makePriExe);
+        await vm.exec(makePriPath, [
+            "new",
+            "/Overwrite",
+            "/Manifest",
+            vm.toVmFile(manifestFile),
+            "/ProjectRoot",
+            vm.toVmFile(path.dirname(assetRoot)),
+            "/ConfigXml",
+            vm.toVmFile(path.join(getTemplatePath("appx"), "priconfig.xml")),
+            "/OutputFile",
+            outFile,
+        ]);
+        // in addition to resources.pri, resources.scale-140.pri and other such files will be generated
+        for (const resourceFile of (await readdir(stageDir.dir)).filter(it => it.startsWith("resources.")).sort()) {
+            mappingList.push([`"${vm.toVmFile(stageDir.getTempFile(resourceFile))}" "${resourceFile}"`]);
+        }
+        makeAppXArgs.push("/l");
+    }
+    let mapping = "[Files]";
+    for (const list of mappingList) {
+        mapping += "\r\n" + list.join("\r\n");
+    }
+    await writeFile(mappingFile, mapping);
+    packager.debugLogger.add(`${config.kind}.mapping`, mapping);
+    if (options.makeappxArgs != null) {
+        makeAppXArgs.push(...options.makeappxArgs);
+    }
+    target.buildQueueManager.add(async () => {
+        try {
+            const makeAppxExe = path.join(vendorPath.kit, "makeappx.exe");
+            // The kit binary is often freshly extracted to a cold cache; on Windows an AV scanner can briefly
+            // hold a deny-write lock long enough that spawning fails with `spawn UNKNOWN`. Wait for it to clear.
+            await ensureNotBusy(makeAppxExe);
+            await vm.exec(vm.toVmFile(makeAppxExe), makeAppXArgs);
+            await packager.signIf(artifactPath);
+        }
+        finally {
+            await stageDir.cleanup();
+        }
+        await packager.emitArtifactBuildCompleted({
+            file: artifactPath,
+            packager,
+            arch,
+            safeArtifactName: packager.computeSafeArtifactName(artifactName, config.kind),
+            target,
+            isWriteUpdateInfo: options.electronUpdaterAware,
+        });
+    });
+}
+//# sourceMappingURL=winAppUtil.js.map