app-builder-lib 26.11.0 → 26.12.0

package/out/targets/snap/SnapTarget.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnapCore = void 0;
+const builder_util_1 = require("builder-util");
+const path = require("path");
+const core_1 = require("../../core");
+const targetUtil_1 = require("../targetUtil");
+/** Abstract base for all snap build strategies (core24, legacy core18/20/22, custom pass-through). */
+class SnapCore {
+    constructor(packager, helper, options) {
+        this.packager = packager;
+        this.helper = helper;
+        this.options = options;
+    }
+}
+exports.SnapCore = SnapCore;
+/** Snap build target — merges `snapcraft` (preferred) and legacy `snap` config, then delegates to the appropriate `SnapCore` strategy. */
+class SnapTarget extends core_1.Target {
+    constructor(name, packager, helper, outDir) {
+        var _a;
+        super(name);
+        this.packager = packager;
+        this.helper = helper;
+        this.outDir = outDir;
+        const { config: { snapcraft, snap }, platformSpecificBuildOptions, } = packager;
+        this.options = (0, builder_util_1.deepAssign)({}, platformSpecificBuildOptions, (_a = snapcraft !== null && snapcraft !== void 0 ? snapcraft : snap) !== null && _a !== void 0 ? _a : {});
+    }
+    async build(appOutDir, arch) {
+        const packager = this.packager;
+        // tslint:disable-next-line:no-invalid-template-strings
+        const artifactName = packager.expandArtifactNamePattern(this.options, "snap", arch, "${name}_${version}_${arch}.${ext}", false);
+        const artifactPath = path.join(this.outDir, artifactName);
+        await packager.info.emitArtifactBuildStarted({
+            targetPresentableName: "snap",
+            file: artifactPath,
+            arch,
+        });
+        const core = this.helper.getSnapCore();
+        const snap = await core.createDescriptor(arch);
+        builder_util_1.log.debug({ snap }, "snapcraft.yaml descriptor created");
+        await core.buildSnap({
+            snap,
+            appOutDir,
+            stageDir: await (0, targetUtil_1.createStageDirPath)(this, packager, arch),
+            snapArch: arch,
+            artifactPath,
+        });
+        const publishConfig = this.findSnapPublishConfig(packager.config);
+        await packager.info.emitArtifactBuildCompleted({
+            file: artifactPath,
+            safeArtifactName: packager.computeSafeArtifactName(artifactName, "snap", arch, false),
+            target: this,
+            arch,
+            packager,
+            publishConfig,
+        });
+    }
+    findSnapPublishConfig(config) {
+        var _a, _b;
+        const fallback = { provider: "snapStore" };
+        if (!config) {
+            return fallback;
+        }
+        const snapConfig = (_a = config.snapcraft) !== null && _a !== void 0 ? _a : config.snap;
+        if (snapConfig === null || snapConfig === void 0 ? void 0 : snapConfig.publish) {
+            return this.findSnapPublishConfigInPublishNode(snapConfig.publish);
+        }
+        if ((_b = config.linux) === null || _b === void 0 ? void 0 : _b.publish) {
+            const configCandidate = this.findSnapPublishConfigInPublishNode(config.linux.publish);
+            if (configCandidate) {
+                return configCandidate;
+            }
+        }
+        if (config.publish) {
+            const configCandidate = this.findSnapPublishConfigInPublishNode(config.publish);
+            if (configCandidate) {
+                return configCandidate;
+            }
+        }
+        return fallback;
+    }
+    findSnapPublishConfigInPublishNode(configPublishNode) {
+        if (!configPublishNode) {
+            return null;
+        }
+        if (Array.isArray(configPublishNode)) {
+            for (const configObj of configPublishNode) {
+                if (this.isSnapStoreOptions(configObj)) {
+                    return configObj;
+                }
+            }
+        }
+        if (typeof configPublishNode === `object` && this.isSnapStoreOptions(configPublishNode)) {
+            return configPublishNode;
+        }
+        return null;
+    }
+    isSnapStoreOptions(configPublishNode) {
+        const snapStoreOptionsCandidate = configPublishNode;
+        return (snapStoreOptionsCandidate === null || snapStoreOptionsCandidate === void 0 ? void 0 : snapStoreOptionsCandidate.provider) === `snapStore`;
+    }
+}
+exports.default = SnapTarget;
+//# sourceMappingURL=SnapTarget.js.map

package/out/targets/snap/SnapTarget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SnapTarget.js","sourceRoot":"","sources":["../../../src/targets/snap/SnapTarget.ts"],"names":[],"mappings":";;;AAAA,+CAAoD;AAEpD,6BAA4B;AAE5B,qCAA4C;AAI5C,8CAAkD;AAGlD,sGAAsG;AACtG,MAAsB,QAAQ;IAG5B,YACqB,QAAuB,EACvB,MAAyB,EACzB,OAAU;QAFV,aAAQ,GAAR,QAAQ,CAAe;QACvB,WAAM,GAAN,MAAM,CAAmB;QACzB,YAAO,GAAP,OAAO,CAAG;IAC5B,CAAC;CAKL;AAZD,4BAYC;AAED,0IAA0I;AAC1I,MAAqB,UAAW,SAAQ,aAAM;IAG5C,YACE,IAAY,EACO,QAAuB,EACvB,MAAyB,EACnC,MAAc;;QAEvB,KAAK,CAAC,IAAI,CAAC,CAAA;QAJQ,aAAQ,GAAR,QAAQ,CAAe;QACvB,WAAM,GAAN,MAAM,CAAmB;QACnC,WAAM,GAAN,MAAM,CAAQ;QAIvB,MAAM,EACJ,MAAM,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,EAC3B,4BAA4B,GAC7B,GAAG,QAAQ,CAAA;QAEZ,IAAI,CAAC,OAAO,GAAG,IAAA,yBAAU,EAAC,EAAE,EAAE,4BAA4B,EAAE,MAAA,SAAS,aAAT,SAAS,cAAT,SAAS,GAAI,IAAI,mCAAI,EAAE,CAAC,CAAA;IACtF,CAAC;IAED,KAAK,CAAC,KAAK,CAAC,SAAiB,EAAE,IAAU;QACvC,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAA;QAC9B,uDAAuD;QACvD,MAAM,YAAY,GAAG,QAAQ,CAAC,yBAAyB,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,mCAAmC,EAAE,KAAK,CAAC,CAAA;QAC/H,MAAM,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,YAAY,CAAC,CAAA;QAEzD,MAAM,QAAQ,CAAC,IAAI,CAAC,wBAAwB,CAAC;YAC3C,qBAAqB,EAAE,MAAM;YAC7B,IAAI,EAAE,YAAY;YAClB,IAAI;SACL,CAAC,CAAA;QAEF,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,CAAA;QAEtC,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAA;QAC9C,kBAAG,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,EAAE,mCAAmC,CAAC,CAAA;QAExD,MAAM,IAAI,CAAC,SAAS,CAAC;YACnB,IAAI;YACJ,SAAS;YACT,QAAQ,EAAE,MAAM,IAAA,+BAAkB,EAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,CAAC;YACxD,QAAQ,EAAE,IAAI;YACd,YAAY;SACb,CAAC,CAAA;QAEF,MAAM,aAAa,GAAG,IAAI,CAAC,qBAAqB,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAA;QAEjE,MAAM,QAAQ,CAAC,IAAI,CAAC,0BAA0B,CAAC;YAC7C,IAAI,EAAE,YAAY;YAClB,gBAAgB,EAAE,QAAQ,CAAC,uBAAuB,CAAC,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,CAAC;YACrF,MAAM,EAAE,IAAI;YACZ,IAAI;YACJ,QAAQ;YACR,aAAa;SACd,CAAC,CAAA;IACJ,CAAC;IAES,qBAAqB,CAAC,MAAsB;;QACpD,MAAM,QAAQ,GAAqB,EAAE,QAAQ,EAAE,WAAW,EAAE,CAAA;QAE5D,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO,QAAQ,CAAA;QACjB,CAAC;QAED,MAAM,UAAU,GAAG,MAAA,MAAM,CAAC,SAAS,mCAAI,MAAM,CAAC,IAAI,CAAA;QAClD,IAAI,UAAU,aAAV,UAAU,uBAAV,UAAU,CAAE,OAAO,EAAE,CAAC;YACxB,OAAO,IAAI,CAAC,kCAAkC,CAAC,UAAU,CAAC,OAAO,CAAC,CAAA;QACpE,CAAC;QAED,IAAI,MAAA,MAAM,CAAC,KAAK,0CAAE,OAAO,EAAE,CAAC;YAC1B,MAAM,eAAe,GAAG,IAAI,CAAC,kCAAkC,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;YAErF,IAAI,eAAe,EAAE,CAAC;gBACpB,OAAO,eAAe,CAAA;YACxB,CAAC;QACH,CAAC;QAED,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;YACnB,MAAM,eAAe,GAAG,IAAI,CAAC,kCAAkC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;YAE/E,IAAI,eAAe,EAAE,CAAC;gBACpB,OAAO,eAAe,CAAA;YACxB,CAAC;QACH,CAAC;QAED,OAAO,QAAQ,CAAA;IACjB,CAAC;IAEO,kCAAkC,CAAC,iBAA0B;QACnE,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACvB,OAAO,IAAI,CAAA;QACb,CAAC;QAED,IAAI,KAAK,CAAC,OAAO,CAAC,iBAAiB,CAAC,EAAE,CAAC;YACrC,KAAK,MAAM,SAAS,IAAI,iBAAiB,EAAE,CAAC;gBAC1C,IAAI,IAAI,CAAC,kBAAkB,CAAC,SAAS,CAAC,EAAE,CAAC;oBACvC,OAAO,SAAS,CAAA;gBAClB,CAAC;YACH,CAAC;QACH,CAAC;QAED,IAAI,OAAO,iBAAiB,KAAK,QAAQ,IAAI,IAAI,CAAC,kBAAkB,CAAC,iBAAiB,CAAC,EAAE,CAAC;YACxF,OAAO,iBAAiB,CAAA;QAC1B,CAAC;QAED,OAAO,IAAI,CAAA;IACb,CAAC;IAEO,kBAAkB,CAAC,iBAA0B;QACnD,MAAM,yBAAyB,GAAG,iBAAqC,CAAA;QACvE,OAAO,CAAA,yBAAyB,aAAzB,yBAAyB,uBAAzB,yBAAyB,CAAE,QAAQ,MAAK,WAAW,CAAA;IAC5D,CAAC;CACF;AA/GD,6BA+GC","sourcesContent":["import { Arch, deepAssign, log } from \"builder-util\"\nimport { SnapStoreOptions } from \"builder-util-runtime\"\nimport * as path from \"path\"\nimport { Configuration } from \"../../configuration\"\nimport { Publish, Target } from \"../../core\"\nimport { LinuxPackager } from \"../../linuxPackager\"\nimport { SnapcraftOptions, SnapOptions } from \"../../options/SnapOptions\"\nimport { LinuxTargetHelper } from \"../LinuxTargetHelper\"\nimport { createStageDirPath } from \"../targetUtil\"\nimport { SnapcraftYAML } from \"./snapcraft\"\n\n/** Abstract base for all snap build strategies (core24, legacy core18/20/22, custom pass-through). */\nexport abstract class SnapCore<T> {\n  protected abstract defaultPlugs: Array<string>\n\n  constructor(\n    protected readonly packager: LinuxPackager,\n    protected readonly helper: LinuxTargetHelper,\n    protected readonly options: T\n  ) {}\n\n  abstract createDescriptor(arch: Arch): Promise<SnapcraftYAML>\n  // snapArch is passed through to subclasses; SnapCoreLegacy forwards it to app-builder as --arch.\n  abstract buildSnap(params: { snap: SnapcraftYAML; appOutDir: string; stageDir: string; snapArch: Arch; artifactPath: string }): Promise<void>\n}\n\n/** Snap build target — merges `snapcraft` (preferred) and legacy `snap` config, then delegates to the appropriate `SnapCore` strategy. */\nexport default class SnapTarget extends Target {\n  readonly options: SnapcraftOptions | SnapOptions\n\n  constructor(\n    name: string,\n    protected readonly packager: LinuxPackager,\n    protected readonly helper: LinuxTargetHelper,\n    readonly outDir: string\n  ) {\n    super(name)\n\n    const {\n      config: { snapcraft, snap },\n      platformSpecificBuildOptions,\n    } = packager\n\n    this.options = deepAssign({}, platformSpecificBuildOptions, snapcraft ?? snap ?? {})\n  }\n\n  async build(appOutDir: string, arch: Arch): Promise<any> {\n    const packager = this.packager\n    // tslint:disable-next-line:no-invalid-template-strings\n    const artifactName = packager.expandArtifactNamePattern(this.options, \"snap\", arch, \"${name}_${version}_${arch}.${ext}\", false)\n    const artifactPath = path.join(this.outDir, artifactName)\n\n    await packager.info.emitArtifactBuildStarted({\n      targetPresentableName: \"snap\",\n      file: artifactPath,\n      arch,\n    })\n\n    const core = this.helper.getSnapCore()\n\n    const snap = await core.createDescriptor(arch)\n    log.debug({ snap }, \"snapcraft.yaml descriptor created\")\n\n    await core.buildSnap({\n      snap,\n      appOutDir,\n      stageDir: await createStageDirPath(this, packager, arch),\n      snapArch: arch,\n      artifactPath,\n    })\n\n    const publishConfig = this.findSnapPublishConfig(packager.config)\n\n    await packager.info.emitArtifactBuildCompleted({\n      file: artifactPath,\n      safeArtifactName: packager.computeSafeArtifactName(artifactName, \"snap\", arch, false),\n      target: this,\n      arch,\n      packager,\n      publishConfig,\n    })\n  }\n\n  protected findSnapPublishConfig(config?: Configuration): SnapStoreOptions | null {\n    const fallback: SnapStoreOptions = { provider: \"snapStore\" }\n\n    if (!config) {\n      return fallback\n    }\n\n    const snapConfig = config.snapcraft ?? config.snap\n    if (snapConfig?.publish) {\n      return this.findSnapPublishConfigInPublishNode(snapConfig.publish)\n    }\n\n    if (config.linux?.publish) {\n      const configCandidate = this.findSnapPublishConfigInPublishNode(config.linux.publish)\n\n      if (configCandidate) {\n        return configCandidate\n      }\n    }\n\n    if (config.publish) {\n      const configCandidate = this.findSnapPublishConfigInPublishNode(config.publish)\n\n      if (configCandidate) {\n        return configCandidate\n      }\n    }\n\n    return fallback\n  }\n\n  private findSnapPublishConfigInPublishNode(configPublishNode: Publish): SnapStoreOptions | null {\n    if (!configPublishNode) {\n      return null\n    }\n\n    if (Array.isArray(configPublishNode)) {\n      for (const configObj of configPublishNode) {\n        if (this.isSnapStoreOptions(configObj)) {\n          return configObj\n        }\n      }\n    }\n\n    if (typeof configPublishNode === `object` && this.isSnapStoreOptions(configPublishNode)) {\n      return configPublishNode\n    }\n\n    return null\n  }\n\n  private isSnapStoreOptions(configPublishNode: Publish): configPublishNode is SnapStoreOptions {\n    const snapStoreOptionsCandidate = configPublishNode as SnapStoreOptions\n    return snapStoreOptionsCandidate?.provider === `snapStore`\n  }\n}\n"]}

package/out/targets/snap/core24.d.ts

@@ -0,0 +1,52 @@
+import { Arch } from "builder-util";
+import { PlugDescriptor, SlotDescriptor, SnapOptions24 } from "../../options/SnapOptions";
+import { SnapCore } from "./SnapTarget";
+import { SnapcraftYAML } from "./snapcraft";
+import { Nullish } from "builder-util-runtime";
+/** Snap build strategy for core24 — generates a native snapcraft.yaml and invokes the snapcraft CLI. */
+export declare class SnapCore24 extends SnapCore<SnapOptions24> {
+    defaultPlugs: string[];
+    readonly configRelativePath = "snap";
+    readonly guiRelativePath: string;
+    createDescriptor(arch: Arch): Promise<SnapcraftYAML>;
+    private isHostMode;
+    /** Writes the snapcraft.yaml, stages app files, then invokes `buildSnap()` to run the actual snapcraft build. */
+    buildSnap(params: {
+        snap: SnapcraftYAML;
+        appOutDir: string;
+        stageDir: string;
+        snapArch: Arch;
+        artifactPath: string;
+    }): Promise<void>;
+    /** Converts `SnapOptions24` into a fully resolved `SnapcraftYAML` descriptor for the given architecture. */
+    mapSnapOptionsToSnapcraftYAML(arch: Arch): Promise<SnapcraftYAML>;
+    /**
+     * Build environment variables with proper defaults
+     */
+    private buildEnvironment;
+    /**
+     * Build default layout for core24 with GNOME platform content snaps (non-extension mode)
+     * This allows the app to access libraries from the gnome-46-2404 and mesa-2404 content snaps
+     */
+    private buildDefaultLayout;
+    /**
+     * Process hooks directory into hook definitions
+     */
+    private processHooks;
+    /**
+     * Normalize assumes list (can be string or array)
+     */
+    normalizeAssumesList(assumes: Array<string> | string | Nullish): string[] | undefined;
+    /**
+     * Process plugs or slots into root-level definitions and app-level references
+     */
+    processPlugOrSlots<T extends Array<string | SlotDescriptor | PlugDescriptor> | SlotDescriptor | PlugDescriptor | null>(items: T): {
+        root: Record<string, unknown> | undefined;
+        app: string[] | undefined;
+    };
+    private isBrowserSandboxAllowed;
+    /**
+     * Expand "default" keyword in arrays of anything
+     */
+    private expandDefaultsInArray;
+}

package/out/targets/snap/core24.js

@@ -0,0 +1,447 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnapCore24 = void 0;
+const builder_util_1 = require("builder-util");
+const fs_extra_1 = require("fs-extra");
+const path = require("path");
+const SnapTarget_1 = require("./SnapTarget");
+const snapcraftBuilder_1 = require("./snapcraftBuilder");
+const yaml = require("js-yaml");
+/** Snap build strategy for core24 — generates a native snapcraft.yaml and invokes the snapcraft CLI. */
+class SnapCore24 extends SnapTarget_1.SnapCore {
+    constructor() {
+        super(...arguments);
+        // browser-support is intentionally absent here; it is auto-injected in mapSnapOptionsToSnapcraftYAML
+        // when the user has not provided custom plugs, so it always lands in both root plugs and app plugs.
+        this.defaultPlugs = ["desktop", "desktop-legacy", "home", "x11", "wayland", "unity7", "network", "gsettings", "audio-playback", "pulseaudio", "opengl"];
+        // Snap file hierarchy:
+        // - snap/gui/ gets automatically copied to meta/gui/ in the final snap
+        // - Desktop files in meta/gui/ are used for menu integration
+        this.configRelativePath = "snap";
+        this.guiRelativePath = path.join(this.configRelativePath, "gui");
+    }
+    async createDescriptor(arch) {
+        return await this.mapSnapOptionsToSnapcraftYAML(arch);
+    }
+    isHostMode() {
+        return this.options.useDestructiveMode === true;
+    }
+    /** Writes the snapcraft.yaml, stages app files, then invokes `buildSnap()` to run the actual snapcraft build. */
+    async buildSnap(params) {
+        const { snap, appOutDir, stageDir, artifactPath } = params;
+        const snapDirResolved = path.resolve(stageDir, this.configRelativePath);
+        const snapcraftYamlPath = path.join(snapDirResolved, "snapcraft.yaml");
+        // Create snap/gui directory for desktop files and icons
+        // Snapcraft will automatically copy snap/gui/ contents to meta/gui/ in the final snap
+        const guiOutput = path.resolve(stageDir, this.guiRelativePath);
+        await (0, fs_extra_1.mkdir)(guiOutput, { recursive: true });
+        const yamlContent = yaml.dump(snap, snapcraftBuilder_1.SNAPCRAFT_YAML_OPTIONS);
+        await (0, fs_extra_1.writeFile)(snapcraftYamlPath, yamlContent, "utf8");
+        builder_util_1.log.debug(snap, "generated snapcraft.yaml");
+        // Copy icon to snap/gui/ directory
+        // Snapcraft will automatically copy this to meta/gui/ in the final snap
+        const desktopExtraProps = {};
+        const icon = this.helper.maxIconPath;
+        if (icon) {
+            const iconFileName = `${snap.name}${path.extname(icon)}`;
+            await (0, fs_extra_1.copy)(icon, path.join(guiOutput, iconFileName));
+            // Icon path will be available at ${SNAP}/meta/gui/<icon-file> after installation
+            desktopExtraProps.Icon = `\${SNAP}/meta/gui/${iconFileName}`;
+        }
+        // Create desktop file in snap/gui/ directory
+        // Snapcraft will automatically copy this to meta/gui/ in the final snap
+        const desktopFilePath = path.join(guiOutput, `${snap.name}.desktop`);
+        await this.helper.writeDesktopEntry(this.options, this.packager.executableName + " %U", desktopFilePath, desktopExtraProps);
+        // Copy app files to the project root `app` directory so `source: app`
+        // in the generated `snapcraft.yaml` (which is under `snap/`) can be
+        // resolved by snapcraft running in the build environment.
+        const appDir = path.resolve(stageDir, "app");
+        if (path.resolve(appDir) !== path.resolve(appOutDir)) {
+            builder_util_1.log.debug({ to: builder_util_1.log.filePath(appDir), from: builder_util_1.log.filePath(appOutDir) }, "copying app files to project root app directory");
+            await (0, builder_util_1.copyDir)(appOutDir, appDir);
+        }
+        // Auto-generate `organize` mapping for the app part so top-level helper
+        // binaries and resources are placed under `app/` inside the snap. Update
+        // the already-written `snapcraft.yaml` so the build sees the mapping.
+        try {
+            const appPart = snap.parts[snap.name];
+            if (appPart) {
+                const entries = (await (0, fs_extra_1.readdir)(appOutDir)).sort();
+                const organize = appPart.organize || {};
+                for (const entry of entries) {
+                    if (!entry) {
+                        continue;
+                    }
+                    if (organize[entry]) {
+                        continue;
+                    }
+                    organize[entry] = `app/${entry}`;
+                }
+                appPart.organize = organize;
+                const updatedYaml = yaml.dump(snap, snapcraftBuilder_1.SNAPCRAFT_YAML_OPTIONS);
+                await (0, fs_extra_1.writeFile)(snapcraftYamlPath, updatedYaml, "utf8");
+                builder_util_1.log.debug({ organize }, "updated snapcraft.yaml with organize mapping");
+            }
+        }
+        catch (e) {
+            builder_util_1.log.warn({ error: e.message }, "failed to generate and update organize mapping");
+        }
+        const buildMode = {
+            useLXD: this.options.useLXD === true,
+            useMultipass: this.options.useMultipass === true,
+            useDestructiveMode: this.options.useDestructiveMode === true,
+            remoteBuild: this.options.remoteBuild || undefined,
+        };
+        if (this.packager.packagerOptions.effectiveOptionComputed != null) {
+            const shouldSkip = await this.packager.packagerOptions.effectiveOptionComputed({ snap, ...buildMode });
+            if (shouldSkip) {
+                return;
+            }
+        }
+        const rootOptions = this.packager.config.snapcraft;
+        await (0, snapcraftBuilder_1.buildSnap)({
+            snapcraftConfig: snap,
+            artifactPath,
+            stageDir,
+            packager: this.packager,
+            cscLink: rootOptions === null || rootOptions === void 0 ? void 0 : rootOptions.cscLink,
+            ...buildMode,
+        });
+    }
+    /** Converts `SnapOptions24` into a fully resolved `SnapcraftYAML` descriptor for the given architecture. */
+    async mapSnapOptionsToSnapcraftYAML(arch) {
+        var _a, _b, _c, _d;
+        const appInfo = this.packager.appInfo;
+        const appName = this.packager.executableName.toLowerCase();
+        const options = this.options;
+        // Default to ["gnome"] in normal builds; no extensions in host/destructive-mode (where the
+        // gnome extension is incompatible). Throw if the user explicitly includes "gnome" in host mode.
+        const hostMode = this.isHostMode();
+        const extensionsList = options.extensions != null ? [...options.extensions] : hostMode ? [] : ["gnome"];
+        if (hostMode && extensionsList.includes("gnome")) {
+            throw new builder_util_1.InvalidConfigurationError(`The "gnome" snapcraft extension is incompatible with host/destructive-mode builds.\n` +
+                `In this mode snapcraft cannot resolve the extension's command-chain source ` +
+                `(/usr/share/snapcraft/extensions/desktop/command-chain) and will fail.\n\n` +
+                `To resolve this, choose one of:\n` +
+                `  1. Remove "gnome" from snapcraft.core24.extensions (or set it to []) and add any\n` +
+                `     required stage-packages manually.\n` +
+                `  2. Switch to an isolated build environment by setting snapcraft.core24.useLXD: true\n` +
+                `     or snapcraft.core24.useMultipass: true instead of useDestructiveMode.\n\n` +
+                `See: https://snapcraft.io/docs/gnome-extension`);
+        }
+        const resolvedExtensions = extensionsList.length > 0 ? extensionsList : undefined;
+        const useGnomeExtension = extensionsList.includes("gnome");
+        // Create the app part
+        const appPart = {
+            plugin: "dump",
+            source: "app",
+            "build-packages": ((_a = options.buildPackages) === null || _a === void 0 ? void 0 : _a.length) ? options.buildPackages : undefined,
+            "stage-packages": this.expandDefaultsInArray(options.stagePackages, snapcraftBuilder_1.DEFAULT_STAGE_PACKAGES),
+            after: this.expandDefaultsInArray(options.after, []),
+            stage: ((_b = options.appPartStage) === null || _b === void 0 ? void 0 : _b.length) ? options.appPartStage : undefined,
+        };
+        // Process plugs and slots
+        // When using GNOME extension, we don't need to manually configure content snaps
+        // The extension will handle: gnome-46-2404, gtk-3-themes, icon-themes, sound-themes
+        let rootPlugs;
+        let appPlugs;
+        if (useGnomeExtension) {
+            // With GNOME extension, only process user-provided custom plugs
+            const result = options.plugs ? this.processPlugOrSlots(options.plugs) : { root: undefined, app: undefined };
+            rootPlugs = result.root;
+            // Extension automatically adds common plugs, so we only add custom ones
+            appPlugs = result.app;
+        }
+        else {
+            // Without GNOME extension, we need manual content snaps
+            const defaultRootPlugs = {
+                "gtk-3-themes": {
+                    interface: "content",
+                    target: "$SNAP/data-dir/themes",
+                    "default-provider": "gtk-common-themes",
+                },
+                "icon-themes": {
+                    interface: "content",
+                    target: "$SNAP/data-dir/icons",
+                    "default-provider": "gtk-common-themes",
+                },
+                "sound-themes": {
+                    interface: "content",
+                    target: "$SNAP/data-dir/sounds",
+                    "default-provider": "gtk-common-themes",
+                },
+                "gnome-46-2404": {
+                    interface: "content",
+                    target: "$SNAP/gnome-platform",
+                    "default-provider": "gnome-46-2404",
+                },
+                "gpu-2404": {
+                    interface: "content",
+                    target: "$SNAP/gpu-2404",
+                    "default-provider": "mesa-2404",
+                },
+            };
+            const result = options.plugs
+                ? this.processPlugOrSlots(options.plugs)
+                : hostMode
+                    ? { root: undefined, app: this.defaultPlugs }
+                    : {
+                        root: defaultRootPlugs,
+                        app: this.defaultPlugs,
+                    };
+            rootPlugs = result.root;
+            appPlugs = result.app;
+        }
+        // Always add browser-support with allow-sandbox so Chromium's internal sandbox
+        // can create user namespaces under strict confinement.  Without allow-sandbox: true
+        // the app crashes immediately with "FATAL: Permission denied (13)" in credentials.cc.
+        // Skip the injection only when the user has explicitly provided their own plugs
+        // (they are responsible for including browser-support in that case).
+        if (!options.plugs) {
+            rootPlugs = { ...rootPlugs, "browser-support": { interface: "browser-support", "allow-sandbox": true } };
+            if (!(appPlugs === null || appPlugs === void 0 ? void 0 : appPlugs.includes("browser-support"))) {
+                appPlugs = [...(appPlugs !== null && appPlugs !== void 0 ? appPlugs : []), "browser-support"];
+            }
+        }
+        const { root: rootSlots, app: appSlots } = options.slots ? this.processPlugOrSlots(options.slots) : { root: undefined, app: undefined };
+        // Build the effective arg list for the snap command.
+        // Start with any user-supplied executableArgs, then conditionally add --no-sandbox
+        // if browser-support with allow-sandbox:true is not present in the resolved plugs
+        // (mirrors the same logic in SnapCoreLegacy.buildSnap).
+        const extraArgs = [...((_c = this.options.executableArgs) !== null && _c !== void 0 ? _c : [])];
+        if (this.options.forceX11 === true) {
+            if (!extraArgs.includes("--ozone-platform=x11")) {
+                extraArgs.push("--ozone-platform=x11");
+            }
+        }
+        if (this.helper.isElectronVersionGreaterOrEqualThan("5.0.0") && !this.isBrowserSandboxAllowed(rootPlugs)) {
+            if (!extraArgs.includes("--no-sandbox")) {
+                extraArgs.push("--no-sandbox");
+            }
+        }
+        const commandSuffix = extraArgs.length > 0 ? ` ${extraArgs.join(" ")}` : "";
+        // Create the app configuration
+        const app = {
+            command: `app/${this.packager.executableName}${commandSuffix}`,
+            "command-chain": undefined, // explicitly undefined so removeNullish strips it; extensions supply their own command-chain
+            plugs: appPlugs,
+            slots: appSlots,
+            autostart: options.autoStart ? `${appName}.desktop` : undefined,
+            desktop: `meta/gui/${appName}.desktop`,
+            extensions: resolvedExtensions,
+        };
+        // Icon path — build-time relative path so snapcraft can find the file in snap/gui/
+        await this.helper.icons;
+        const iconPath = this.helper.maxIconPath != null ? `snap/gui/${appName}${path.extname(this.helper.maxIconPath)}` : undefined;
+        // Process hooks if configured
+        const hooksConfig = options.hooks;
+        const hooks = hooksConfig ? await this.processHooks(hooksConfig) : undefined;
+        // Parts configuration - the extension automatically adds a gnome/sdk part
+        // Don't manually add desktop-launch when using the extension
+        const parts = {
+            [appName]: appPart,
+        };
+        // Note: `organize` will be generated later in `buildSnap` based on the
+        // actual contents of the built app directory so helper binaries and
+        // resources are automatically moved under `app/` in the snap.
+        // Build the snapcraft configuration
+        const snapcraft = {
+            // Required fields
+            name: appName,
+            base: "core24",
+            confinement: options.confinement || "strict",
+            parts: parts,
+            // Architecture/Platform — only needed for cross-compilation; snapcraft 8
+            // defaults to host arch and snapcraft 7 rejects this field entirely.
+            ...(arch !== (0, builder_util_1.archFromString)(process.arch)
+                ? {
+                    platforms: {
+                        [(0, builder_util_1.toLinuxArchString)(arch, "snap")]: {
+                            "build-for": (0, builder_util_1.toLinuxArchString)(arch, "snap"),
+                            "build-on": (0, builder_util_1.toLinuxArchString)((0, builder_util_1.archFromString)(process.arch), "snap"),
+                        },
+                    },
+                }
+                : {}),
+            // Metadata - with fallbacks from appInfo
+            version: appInfo.version,
+            summary: options.summary || appInfo.productName,
+            description: this.helper.getDescription(options),
+            grade: options.grade || "stable",
+            title: options.title || appInfo.productName,
+            icon: iconPath,
+            // Build configuration
+            compression: options.compression || undefined,
+            assumes: this.normalizeAssumesList(options.assumes),
+            // Environment
+            environment: this.buildEnvironment(options),
+            // User-supplied layout always wins. Without gnome extension and not in host mode, fall back to content-snap defaults.
+            layout: (_d = options.layout) !== null && _d !== void 0 ? _d : (useGnomeExtension || hostMode ? undefined : this.buildDefaultLayout(options)),
+            // Interfaces
+            plugs: rootPlugs,
+            slots: rootSlots,
+            // Hooks
+            hooks: hooks,
+            // Apps
+            apps: {
+                [appName]: app,
+            },
+        };
+        return (0, builder_util_1.removeNullish)(snapcraft);
+    }
+    /**
+     * Build environment variables with proper defaults
+     */
+    buildEnvironment(options) {
+        var _a;
+        const env = {};
+        // Add default TMPDIR for Electron/Chromium apps
+        if (!((_a = options.environment) === null || _a === void 0 ? void 0 : _a.TMPDIR)) {
+            env.TMPDIR = "$XDG_RUNTIME_DIR";
+        }
+        if (options.environment) {
+            (0, builder_util_1.deepAssign)(env, options.environment);
+        }
+        return Object.keys(env).length > 0 ? env : undefined;
+    }
+    /**
+     * Build default layout for core24 with GNOME platform content snaps (non-extension mode)
+     * This allows the app to access libraries from the gnome-46-2404 and mesa-2404 content snaps
+     */
+    buildDefaultLayout(options) {
+        // If user provides custom layout, use that instead
+        if (options.layout) {
+            return options.layout;
+        }
+        // Default layout for core24 Electron apps using GNOME content snaps WITHOUT extension
+        return {
+            "/usr/lib/$CRAFT_ARCH_TRIPLET_BUILD_FOR/webkit2gtk-4.0": {
+                bind: "$SNAP/gnome-platform/usr/lib/$CRAFT_ARCH_TRIPLET_BUILD_FOR/webkit2gtk-4.0",
+            },
+            "/usr/lib/$CRAFT_ARCH_TRIPLET_BUILD_FOR/webkit2gtk-4.1": {
+                bind: "$SNAP/gnome-platform/usr/lib/$CRAFT_ARCH_TRIPLET_BUILD_FOR/webkit2gtk-4.1",
+            },
+            "/usr/share/xml/iso-codes": {
+                bind: "$SNAP/gnome-platform/usr/share/xml/iso-codes",
+            },
+            "/usr/share/libdrm": {
+                bind: "$SNAP/gpu-2404/libdrm",
+            },
+            "/usr/share/drirc.d": {
+                symlink: "$SNAP/gpu-2404/drirc.d",
+            },
+        };
+    }
+    /**
+     * Process hooks directory into hook definitions
+     */
+    async processHooks(hooksPath) {
+        try {
+            const buildResourcesDir = this.packager.buildResourcesDir;
+            const hooksDir = path.resolve(buildResourcesDir, hooksPath);
+            if (!hooksDir.startsWith(buildResourcesDir + path.sep) && hooksDir !== buildResourcesDir) {
+                throw new builder_util_1.InvalidConfigurationError(`snapcraft.core24.hooks must resolve within the build resources directory (got "${hooksDir}")`);
+            }
+            const hookFiles = await (0, fs_extra_1.readdir)(hooksDir);
+            if (hookFiles.length === 0) {
+                return undefined;
+            }
+            const hooks = {};
+            for (const hookFile of hookFiles) {
+                const hookName = path.basename(hookFile, path.extname(hookFile));
+                if (!(0, builder_util_1.isValidKey)(hookName)) {
+                    throw new builder_util_1.InvalidConfigurationError(`Invalid hook name: ${hookName}`);
+                }
+                hooks[hookName] = {
+                // Hook definitions will be populated by snapcraft from the files
+                // Just register that these hooks exist
+                };
+            }
+            return hooks;
+        }
+        catch (e) {
+            builder_util_1.log.error({ message: e.message }, "error processing Snap hooks directory");
+            throw e;
+        }
+    }
+    /**
+     * Normalize assumes list (can be string or array)
+     */
+    normalizeAssumesList(assumes) {
+        if (!assumes) {
+            return undefined;
+        }
+        if (typeof assumes === "string") {
+            return [assumes];
+        }
+        return assumes.length > 0 ? assumes : undefined;
+    }
+    /**
+     * Process plugs or slots into root-level definitions and app-level references
+     */
+    processPlugOrSlots(items) {
+        if (!items || (Array.isArray(items) && items.length === 0)) {
+            return { root: undefined, app: undefined };
+        }
+        const root = {};
+        const app = [];
+        // Handle single descriptor object
+        if (!Array.isArray(items)) {
+            Object.entries(items).forEach(([name, config]) => {
+                if (!(0, builder_util_1.isValidKey)(name)) {
+                    throw new Error(`Invalid plug/slot name: ${name}`);
+                }
+                root[name] = config;
+                app.push(name);
+            });
+            return { root, app };
+        }
+        // Handle array - support "default" keyword
+        const processedItems = this.expandDefaultsInArray(items, this.defaultPlugs);
+        for (const item of processedItems !== null && processedItems !== void 0 ? processedItems : []) {
+            if (typeof item === "string") {
+                // Simple string reference
+                app.push(item);
+            }
+            else {
+                // Descriptor object with configuration
+                Object.entries(item).forEach(([name, config]) => {
+                    if (!(0, builder_util_1.isValidKey)(name)) {
+                        throw new Error(`Invalid plug/slot name: ${name}`);
+                    }
+                    root[name] = config;
+                    app.push(name);
+                });
+            }
+        }
+        return { root: Object.keys(root).length > 0 ? root : undefined, app: app.length > 0 ? app : undefined };
+    }
+    isBrowserSandboxAllowed(plugs) {
+        if (!plugs) {
+            return false;
+        }
+        for (const plug of Object.values(plugs)) {
+            if ((plug === null || plug === void 0 ? void 0 : plug.interface) === "browser-support" && plug["allow-sandbox"] === true) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Expand "default" keyword in arrays of anything
+     */
+    expandDefaultsInArray(items, defaults) {
+        const result = [];
+        for (const item of items !== null && items !== void 0 ? items : []) {
+            if (typeof item === "string" && item === "default") {
+                result.push(...defaults);
+            }
+            else {
+                result.push(item);
+            }
+        }
+        return result.length > 0 ? result : undefined;
+    }
+}
+exports.SnapCore24 = SnapCore24;
+//# sourceMappingURL=core24.js.map