@gjsify/cli 0.39.0 → 0.40.0

package/lib/commands/ship.js

@@ -0,0 +1,217 @@
+// `gjsify ship` — turn a built application into something a stranger can
+// install (ADR 0024).
+//
+// One payload, produced once, then wrapped per format. The command itself is
+// thin on purpose: every decision worth testing lives in `utils/ship/*` as a
+// pure function, and what is left here is filesystem work and printing.
+//
+// Scope today is Linux and `--app gjs`: no runtime is bundled, because GJS and
+// GTK come from the distribution and shipping ~100 MiB of them would be cargo
+// cult (ADR 0024 § 4). macOS and Windows layouts, and Flatpak as a target under
+// this command, are the later stages of the same ADR.
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { basename, join, relative, resolve } from 'node:path';
+import { Config } from '../config.js';
+import { renderDesktopEntry, renderMetainfoApp, renderMetainfoCli, validateAppMetadata, } from '../utils/app-metadata.js';
+import { readPackageJson } from '../utils/pkg-json.js';
+import { describeExit, spawnToCompletion } from '../utils/spawn.js';
+import { buildDeb } from '../utils/ship/deb.js';
+import { deriveDepends, warnAboutGjsFloor } from '../utils/ship/depends.js';
+import { discoverPayload } from '../utils/ship/discover.js';
+import { resolveFormats, FORMAT_IDS } from '../utils/ship/formats.js';
+import { scanGiNamespaces } from '../utils/ship/gi-namespaces.js';
+import { buildTimestamp, isArchIndependent } from '../utils/ship/payload.js';
+import { planOverlay, planStage } from '../utils/ship/plan.js';
+import { renderLauncher } from '../utils/ship/launcher.js';
+import { buildRpm } from '../utils/ship/rpm.js';
+import { declaredBundlePath, resolveShipSettings } from '../utils/ship/settings.js';
+import { readStage, writeStage } from '../utils/ship/stage-writer.js';
+const LOG = '[gjsify ship]';
+export const shipCommand = {
+    command: 'ship',
+    description: `Build installable artifacts (${FORMAT_IDS.join(', ')}) from the current project.`,
+    builder: (yargs) => yargs
+        .option('target', {
+        type: 'string',
+        array: true,
+        description: `Formats to build, comma-separated or repeated. Default: ${FORMAT_IDS.join(',')}.`,
+    })
+        .option('out', {
+        type: 'string',
+        normalize: true,
+        description: 'Output root, relative to the project. Default: `gjsify.ship.outDir`, else `ship`.',
+    })
+        .option('stage', {
+        type: 'boolean',
+        default: false,
+        description: 'Produce the staged payload and stop, without packing anything.',
+    })
+        .option('skip-build', {
+        type: 'boolean',
+        default: false,
+        description: "Package what is already built instead of running the project's `build` script.",
+    })
+        .option('arch', {
+        type: 'string',
+        description: 'Target architecture in `process.arch` spelling. Default: this host.',
+    })
+        .option('verbose', {
+        type: 'boolean',
+        default: false,
+        description: 'Print each staged file and the GI namespaces the bundle imports.',
+    }),
+    handler: async (args) => {
+        const projectDir = process.cwd();
+        const config = new Config();
+        // No `.catch(() => ({}))` here, unlike the flatpak commands: a config
+        // file that fails to load would silently become "no config", and the
+        // result is a shipped artifact carrying default metadata the author
+        // never chose. An unreadable config is an error worth printing.
+        const configData = await config.forCommand(projectDir);
+        const ship = configData.ship ?? {};
+        const flatpak = configData.flatpak ?? {};
+        assertShippableTarget(configData.app);
+        const pkg = (readPackageJson(join(projectDir, 'package.json')) ?? {});
+        // Resolved before anything is built or written: a typo'd `--target`
+        // should not cost a build and leave a half-written `ship/stage/`.
+        const formats = resolveFormats(args.target ?? ship.targets ?? FORMAT_IDS);
+        if (!args['skip-build'])
+            await runProjectBuild(projectDir);
+        const discovered = discoverPayload({
+            projectDir,
+            pkg,
+            ship,
+            flatpakIcon: flatpak.icon,
+            declaredBundle: declaredBundlePath(pkg, ship),
+        });
+        const { settings, metadata, warnings } = resolveShipSettings({
+            projectDir,
+            pkg,
+            ship,
+            flatpak,
+            cli: { outDir: args.out, arch: args.arch },
+            discovered,
+        });
+        for (const warning of warnings)
+            console.warn(`${LOG} ${warning}`);
+        const mtime = buildTimestamp(settings.bundlePath);
+        const metadataInputs = {
+            appId: settings.appId,
+            name: settings.name,
+            command: settings.binaryName,
+            kind: settings.kind,
+            metadata,
+            configKey: 'gjsify.ship',
+            copyrightYear: new Date(mtime * 1000).getUTCFullYear(),
+        };
+        // Warn rather than fail: an incomplete AppStream component still
+        // installs and still runs. It is app STORES that will reject it, and
+        // that is a different day's problem than getting the package built.
+        for (const missing of validateAppMetadata(metadataInputs)) {
+            console.warn(`${LOG} ${missing.field} is not set — ${missing.hint}`);
+        }
+        const stageInputs = {
+            bundleFiles: discovered.bundleFiles,
+            launcher: renderLauncher(settings, basename(settings.bundlePath)),
+            metainfo: settings.kind === 'app' ? renderMetainfoApp(metadataInputs) : renderMetainfoCli(metadataInputs),
+            desktopEntry: settings.kind === 'app' ? renderDesktopEntry(metadataInputs) : undefined,
+            licenseText: settings.licenseFile === undefined ? undefined : readFileSync(settings.licenseFile, 'utf-8'),
+        };
+        const outRoot = resolve(projectDir, settings.outDir);
+        const stageDir = join(outRoot, 'stage');
+        const staged = planStage(settings, stageInputs);
+        writeStage(stageDir, staged);
+        console.log(`${LOG} staged ${staged.length} file(s) in ${relative(projectDir, stageDir)}/`);
+        if (args.verbose)
+            for (const file of staged)
+                console.log(`${LOG}   ${file.path}`);
+        if (args.stage)
+            return;
+        const namespaces = scanGiNamespaces(readFileSync(settings.bundlePath, 'utf-8'));
+        if (args.verbose)
+            console.log(`${LOG} gi namespaces: ${namespaces.join(', ') || '(none)'}`);
+        const artifacts = [];
+        for (const format of formats) {
+            artifacts.push(await packOne({ format, settings, stageInputs, staged, stageDir, outRoot, namespaces, mtime }));
+        }
+        for (const artifact of artifacts) {
+            console.log(`${LOG} ${artifact.format}: ${relative(projectDir, artifact.path)} (${artifact.size} bytes)`);
+        }
+    },
+};
+async function packOne(input) {
+    const { format, settings, stageDir, outRoot, mtime } = input;
+    const overlay = planOverlay(settings, format, input.stageInputs);
+    const overlayDir = join(outRoot, 'overlay', format.id);
+    writeStage(overlayDir, overlay);
+    const payload = readStage([stageDir, overlayDir], [...input.staged, ...overlay]);
+    const depends = deriveDepends(format.id, {
+        namespaces: input.namespaces,
+        kind: settings.kind,
+        hasSchemas: settings.schemaFiles.length > 0,
+        extra: settings.extraDepends[format.id],
+        typelibPackages: settings.typelibPackages,
+        minGjsVersion: settings.minGjsVersion,
+    });
+    for (const warning of warnAboutGjsFloor(format.id, settings.minGjsVersion))
+        console.warn(`${LOG} ${warning}`);
+    const archLabel = format.archName(settings.arch, isArchIndependent(payload));
+    const common = { settings, payload, prefix: format.prefix, depends, archLabel, mtime };
+    const bytes = format.id === 'deb' ? await buildDeb(common) : await buildRpm(common);
+    const outDir = join(outRoot, 'out');
+    mkdirSync(outDir, { recursive: true });
+    const target = join(outDir, format.fileName(settings, archLabel));
+    writeFileSync(target, bytes);
+    return { format: format.id, path: target, size: bytes.byteLength };
+}
+/**
+ * Refuse a build target this command cannot package correctly.
+ *
+ * The launcher execs `gjs -m <bundle>`, so a `--app node` bundle would produce
+ * a package that installs and then fails at startup — and ADR 0024 § 4 says
+ * that case needs a BUNDLED Node, whose delivery (fetched at ship time versus a
+ * platform package) is still an open decision. Better to say so than to ship
+ * the broken half of it.
+ *
+ * An undeclared target is the common case for a GJS app and is allowed: `app`
+ * otherwise defaults to the HOST runtime, which would refuse a perfectly good
+ * GJS project merely for running this command under Node.
+ */
+function assertShippableTarget(app) {
+    if (app === undefined || app === 'gjs')
+        return;
+    throw new Error(`gjsify ship: this project declares \`gjsify.app: "${app}"\`, and only \`gjs\` can be packaged today. ` +
+        'The launcher execs `gjs -m <bundle>`, so any other target would install and then fail to start. ' +
+        'ADR 0024 § 4 has the runtime-per-OS table and what is still open for the other targets.');
+}
+/**
+ * Run the project's own `build` script, as a CHILD process.
+ *
+ * NOT dispatched in-process, even though `cli-app.ts` exists to allow exactly
+ * that: `gjsify run`'s script path ends in `return process.exit(code)` on every
+ * branch — deliberately, because under GJS a bare `process.exit` falls through
+ * and it needs exactly one exit scheduled. Calling it from here would end the
+ * process after the build and never reach the packing, and neither the types
+ * nor a `--skip-build` test would have caught it.
+ *
+ * `completion: 'return'` because this handler returns afterwards; on GJS that
+ * selects the blocking path rather than arming a main loop only an exit quits.
+ */
+async function runProjectBuild(projectDir) {
+    const pkg = readPackageJson(join(projectDir, 'package.json'));
+    if (typeof pkg?.scripts?.build !== 'string') {
+        throw new Error('gjsify ship: this project has no `build` script to run. Add one, or pass --skip-build to ' +
+            'package what is already built.');
+    }
+    console.log(`${LOG} running the project's build script`);
+    const result = await spawnToCompletion('gjsify', ['run', 'build'], {
+        completion: 'return',
+        cwd: projectDir,
+        stdio: 'inherit',
+        notFound: () => new Error('gjsify ship: `gjsify` is not on PATH, so the project build cannot be run. Build the project ' +
+            'yourself and pass --skip-build.'),
+    });
+    if (result.code !== 0) {
+        throw new Error(`gjsify ship: the project's build script failed${describeExit(result)}.`);
+    }
+}

package/lib/config.d.ts

@@ -24,5 +24,17 @@ export declare class Config {
         globals?: string;
         excludeGlobals?: string[];
     }>;
+    /**
+     * The config for a command that is NOT a build — `gjsify flatpak …`,
+     * `gjsify ship …`.
+     *
+     * They all want exactly what the loader already produces: the merged
+     * `package.json#gjsify` + config-file object, with none of `forBuild`'s
+     * build-specific defaulting. Reaching it through `forBuild({} as never)`
+     * — five copies of that line before this method existed — lies to the type
+     * system and drags a tsconfig read and bundler defaults into a command
+     * that has no bundle.
+     */
+    forCommand(searchFrom?: string): Promise<ConfigData>;
     forBuild(cliArgs: ArgumentsCamelCase<CliBuildOptions>): Promise<ConfigData>;
 }

package/lib/config.js

@@ -233,6 +233,21 @@ export class Config {
             excludeGlobals: config.nodeScript?.excludeGlobals ?? config.excludeGlobals,
         };
     }
+    /**
+     * The config for a command that is NOT a build — `gjsify flatpak …`,
+     * `gjsify ship …`.
+     *
+     * They all want exactly what the loader already produces: the merged
+     * `package.json#gjsify` + config-file object, with none of `forBuild`'s
+     * build-specific defaulting. Reaching it through `forBuild({} as never)`
+     * — five copies of that line before this method existed — lies to the type
+     * system and drags a tsconfig read and bundler defaults into a command
+     * that has no bundle.
+     */
+    async forCommand(searchFrom = process.cwd()) {
+        const { config } = await this.load(searchFrom);
+        return config;
+    }
     async forBuild(cliArgs) {
         const configFile = await this.load(process.cwd());
         const configData = { ...configFile.config };

package/lib/types/config-data.d.ts

@@ -171,6 +171,13 @@ export interface ConfigData {
      * defaults declaratively. CLI flags override these.
      */
     flatpak?: ConfigDataFlatpak;
+    /**
+     * Config for `gjsify ship` — the installable artifacts (`.deb`, `.rpm`)
+     * built from one staged payload. Metadata left unset here falls back to
+     * `gjsify.flatpak`, because both blocks describe the SAME application
+     * (ADR 0024 § 8) and no project should have to write it twice.
+     */
+    ship?: ConfigDataShip;
     /**
      * Config for `gjsify format` / `lint` / `fix`. A thin shell: oxc's own
      * `.oxfmtrc.json` / `.oxlintrc.json` are the real configuration files.
@@ -197,52 +204,14 @@ export interface ConfigDataTest {
     /** Default runtimes when `--runtime` not specified. Default: `['gjs', 'node']`. */
     runtimes?: Array<'gjs' | 'node'>;
 }
-/** Flatpak-toolchain config for the `gjsify flatpak` subcommand group. */
-export interface ConfigDataFlatpak {
-    /** Reverse-DNS app id, e.g. `eu.jumplink.Learn6502`. Defaults to `package.json#name` if it looks like a reverse-DNS id. */
-    appId?: string;
-    /**
-     * Runtime family. Default `'gnome'` — needed at runtime by GJS bundles
-     * for GLib/GObject/GIO. `'freedesktop'` is only suitable for non-gjsify
-     * CLI tools (no GJS interpreter ships in the Freedesktop runtime).
-     */
-    runtime?: 'gnome' | 'freedesktop';
-    /** Runtime/SDK version, e.g. `'50'` for GNOME or `'24.08'` for Freedesktop. */
-    runtimeVersion?: string;
-    /**
-     * Extra SDK extensions for the manifest, e.g.
-     * `['org.freedesktop.Sdk.Extension.llvm17']` for native code needing a specific
-     * toolchain. Leave empty for pure gjsify projects: the GNOME runtime already
-     * ships GJS + GLib + libsoup and `gjsify build` produces a self-contained bundle
-     * that needs no build-time Node.
-     */
-    sdkExtensions?: string[];
-    /** Path components prepended to PATH inside the build sandbox. */
-    appendPath?: string[];
-    /** The binary name to run (`/app/bin/<command>`). Defaults to `appId`. */
-    command?: string;
-    /** Finish-args (capabilities). Default depends on `runtime` + `--cli-only`. */
-    finishArgs?: string[];
-    /** Extra Flatpak modules prepended before the app's own meson/simple module (e.g. `blueprint-compiler` build). */
-    extraModules?: unknown[];
-    /**
-     * Full replacement for the manifest's `modules` array: used verbatim, with
-     * neither `extraModules` nor the meson default added. For CLI tools that ship a
-     * pre-built bundle and install via shell commands (`buildsystem: simple`).
-     */
-    modules?: unknown[];
-    /** Cleanup glob patterns applied to the final manifest, e.g. `['/include', '/lib/pkgconfig']`. */
-    cleanup?: string[];
-    /** Source-of-truth lockfile for `gjsify flatpak deps` — `yarn.lock` or `package-lock.json`. */
-    lockfile?: string;
-    /**
-     * GitHub-Actions container image override for `gjsify flatpak ci`. Default is
-     * derived from runtime + runtimeVersion, e.g. gnome+50 →
-     * `ghcr.io/flathub-infra/flatpak-github-actions:gnome-50`.
-     */
-    ciContainer?: string;
-    /** Branches the generated workflow triggers on. Default `['main']`. */
-    ciBranches?: string[];
+/**
+ * The app metadata every install format needs — AppStream MetaInfo fields plus
+ * what a freedesktop `.desktop` entry is built from. Shared on purpose: a
+ * `.deb`, an `.rpm`, a Flatpak and a macOS bundle all describe the SAME
+ * application, so this block belongs to the app rather than to whichever packer
+ * happens to read it (ADR 0024 § 8).
+ */
+export interface AppMetadata {
     /**
      * `'app'` (default) → desktop-application MetaInfo, GUI finish-args, .desktop +
      * icon required. `'cli'` → console-application MetaInfo with
@@ -394,6 +363,127 @@ export interface ConfigDataFlatpak {
         displayLengthMin?: number;
         controls?: Array<'keyboard' | 'pointing' | 'touch' | 'gamepad' | 'tablet' | 'console'>;
     };
+}
+/**
+ * `gjsify ship` configuration — the packaging half of {@link AppMetadata}.
+ *
+ * Everything here has a derived default; a project that already has a
+ * `gjsify.flatpak` block usually needs no `gjsify.ship` block at all.
+ */
+export interface ConfigDataShip extends AppMetadata {
+    /** Reverse-DNS app id. Falls back to `gjsify.flatpak.appId`, then `package.json#name`. */
+    appId?: string;
+    /**
+     * Package name and `bin/` entry. Default: `package.json#name` with the npm
+     * scope stripped, lowercased, non-alphanumerics folded to `-`.
+     */
+    binaryName?: string;
+    /** Override the upstream version. Default: `package.json#version`, normalised. */
+    version?: string;
+    /** Package revision within one upstream version (deb revision / rpm release). Default `'1'`. */
+    release?: string;
+    /** `Maintainer:` / `Packager:` as `Name <email>`. Default: `package.json#author`. */
+    maintainer?: string;
+    /** Formats to build when `--target` is not given. Default `['deb', 'rpm']`. */
+    targets?: string[];
+    /** Output root, relative to the project. Default `'ship'`. */
+    outDir?: string;
+    /**
+     * The built bundle `bin/<name>` executes. Default: `gjsify.main`, then
+     * `package.json#main`. Its whole directory is staged into `lib/<name>/`.
+     */
+    bundle?: string;
+    /** Icon file, or a directory of them. Sizes are read from the path or the filename. */
+    icon?: string;
+    /** A `*.gschema.xml` file, or a directory of them. */
+    schemas?: string;
+    /** Licence file. Default: the first of LICENSE, LICENSE.md, LICENSE.txt, COPYING. */
+    licenseFile?: string;
+    /** deb `Section:`. Default: derived from `categories`. */
+    section?: string;
+    /** rpm `Group:`. Default: derived from `categories`. */
+    group?: string;
+    /**
+     * Minimum GJS the emitted dependency asks for. Default `'1.86'` — what the
+     * bundler targets. Lower it only if the bundle genuinely runs on an older
+     * GJS: no released Debian ships 1.86, so the default makes a `.deb` that
+     * apt refuses on trixie rather than one that installs and then fails to
+     * start.
+     */
+    minGjsVersion?: string;
+    /**
+     * Runtime dependencies appended to the set derived from the bundle's
+     * `gi://` imports — the escape hatch for a namespace the table does not
+     * know, and for anything that is not a typelib at all.
+     */
+    depends?: {
+        deb?: string[];
+        rpm?: string[];
+    };
+    /**
+     * GI namespace → the package that ships its typelib, filling gaps in the
+     * built-in table (`Nautilus-3.0`, a namespace from a private library, …).
+     * A row here wins over the built-in one.
+     *
+     * This is what unblocks a namespace `gjsify ship` does not know; `depends`
+     * is for dependencies that are not typelibs at all and deliberately does
+     * not silence the unmapped-namespace failure.
+     */
+    typelibPackages?: Record<string, {
+        deb: string;
+        rpm: string;
+    }>;
+    /** Extra payload entries: prefix-relative destination → project-relative source. */
+    extraFiles?: Record<string, string>;
+    /** Arguments the launcher appends before the user's own. */
+    execArgs?: string[];
+}
+/** Flatpak-toolchain config for the `gjsify flatpak` subcommand group. */
+export interface ConfigDataFlatpak extends AppMetadata {
+    /** Reverse-DNS app id, e.g. `eu.jumplink.Learn6502`. Defaults to `package.json#name` if it looks like a reverse-DNS id. */
+    appId?: string;
+    /**
+     * Runtime family. Default `'gnome'` — needed at runtime by GJS bundles
+     * for GLib/GObject/GIO. `'freedesktop'` is only suitable for non-gjsify
+     * CLI tools (no GJS interpreter ships in the Freedesktop runtime).
+     */
+    runtime?: 'gnome' | 'freedesktop';
+    /** Runtime/SDK version, e.g. `'50'` for GNOME or `'24.08'` for Freedesktop. */
+    runtimeVersion?: string;
+    /**
+     * Extra SDK extensions for the manifest, e.g.
+     * `['org.freedesktop.Sdk.Extension.llvm17']` for native code needing a specific
+     * toolchain. Leave empty for pure gjsify projects: the GNOME runtime already
+     * ships GJS + GLib + libsoup and `gjsify build` produces a self-contained bundle
+     * that needs no build-time Node.
+     */
+    sdkExtensions?: string[];
+    /** Path components prepended to PATH inside the build sandbox. */
+    appendPath?: string[];
+    /** The binary name to run (`/app/bin/<command>`). Defaults to `appId`. */
+    command?: string;
+    /** Finish-args (capabilities). Default depends on `runtime` + `--cli-only`. */
+    finishArgs?: string[];
+    /** Extra Flatpak modules prepended before the app's own meson/simple module (e.g. `blueprint-compiler` build). */
+    extraModules?: unknown[];
+    /**
+     * Full replacement for the manifest's `modules` array: used verbatim, with
+     * neither `extraModules` nor the meson default added. For CLI tools that ship a
+     * pre-built bundle and install via shell commands (`buildsystem: simple`).
+     */
+    modules?: unknown[];
+    /** Cleanup glob patterns applied to the final manifest, e.g. `['/include', '/lib/pkgconfig']`. */
+    cleanup?: string[];
+    /** Source-of-truth lockfile for `gjsify flatpak deps` — `yarn.lock` or `package-lock.json`. */
+    lockfile?: string;
+    /**
+     * GitHub-Actions container image override for `gjsify flatpak ci`. Default is
+     * derived from runtime + runtimeVersion, e.g. gnome+50 →
+     * `ghcr.io/flathub-infra/flatpak-github-actions:gnome-50`.
+     */
+    ciContainer?: string;
+    /** Branches the generated workflow triggers on. Default `['main']`. */
+    ciBranches?: string[];
     /**
      * Flathub tracking-repo override for `gjsify flatpak sync-flathub` / `diff`.
      * Default `flathub/<appId>`; set when the upstream repo deviates.

package/lib/utils/app-metadata.d.ts

@@ -0,0 +1,51 @@
+import type { AppMetadata } from '../types/config-data.js';
+/** Everything a renderer needs that is not part of {@link AppMetadata} itself. */
+export interface AppMetadataInputs {
+    /** Reverse-DNS application id — the MetaInfo `<id>` and the icon/desktop basename. */
+    appId: string;
+    /** Human-readable display name. */
+    name: string;
+    /** The binary to launch (`Exec=`, and the default `<provides><binary>`). */
+    command: string;
+    /** `'app'` renders a desktop-application component, `'cli'` a console one. */
+    kind: 'app' | 'cli';
+    metadata: AppMetadata;
+    /**
+     * Config path the validator names in its hints, e.g. `gjsify.flatpak` or
+     * `gjsify.ship`. Both read the same fields, so the hint has to say which
+     * block the caller was actually reading.
+     */
+    configKey: string;
+    /**
+     * Year for the copyright comment. Passed in rather than read from the
+     * clock: this XML is PAYLOAD, so `new Date()` here makes the artifact's
+     * bytes depend on when it was packed — a reproducibility hole no test
+     * running inside one second can see. Defaults to the current year for
+     * callers that write the file to a source tree rather than into a package.
+     */
+    copyrightYear?: number;
+}
+export interface MissingFieldError {
+    field: string;
+    hint: string;
+}
+/**
+ * Validate that the metadata has the minimum set of fields AppStream needs.
+ * Returns the missing fields with actionable hints; an empty list means OK.
+ */
+export declare function validateAppMetadata(inputs: AppMetadataInputs): MissingFieldError[];
+/** Render the MetaInfo XML for a desktop application. */
+export declare function renderMetainfoApp(inputs: AppMetadataInputs): string;
+/** Render the MetaInfo XML for a console application. */
+export declare function renderMetainfoCli(inputs: AppMetadataInputs): string;
+/**
+ * Render the `.desktop` entry (app kind only).
+ *
+ * `Exec=` carries a field code when the app declares MIME types, because a
+ * desktop entry with `MimeType=` and no `%f`/`%u` is registered as a handler
+ * that is then launched with no argument — the file the user double-clicked is
+ * dropped on the floor, and `desktop-file-validate` says so. `x-scheme-handler/*`
+ * wins over file types: a URL handler must take `%u`.
+ */
+export declare function renderDesktopEntry(inputs: AppMetadataInputs): string;
+export declare function escapeXml(value: string): string;