cross-packer 0.1.0

package/dist/asar/packer/stream-builder.d.ts

@@ -0,0 +1,18 @@
+import { type FileFilter, type FileSet } from '../../shared/types.ts';
+/** A fileSet plus transformed contents collected during packing. */
+interface PackedFileSet extends FileSet {
+    transformedFiles?: Map<number, string>;
+}
+export interface PackAsarOptions {
+    outputPath: string;
+    unpackPattern?: FileFilter;
+    smartUnpack?: boolean;
+    unpackDirs?: string[];
+    defaultDestination?: string;
+    workspaceRoot?: string;
+}
+export declare function packAsarFromFileSets(fileSets: PackedFileSet[], options: PackAsarOptions): Promise<{
+    asarPath: string;
+    unpackedDir: string | undefined;
+}>;
+export {};

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/config/index.d.ts

@@ -0,0 +1,97 @@
+import type { PrebuiltModuleRule } from '../asar/fileset/platform-fileset.ts';
+import type { ExtraResourceEntry } from '../packer/common/extra-resources.ts';
+import type { Arch, NodePlatform } from '../shared/platform.ts';
+import type { FileVisitor, JsonObject } from '../shared/types.ts';
+export declare const DEFAULT_CONFIG_FILENAME = "cross-packer.config.mjs";
+export interface NormalizedConfig {
+    name: string;
+    productName: string;
+    artifactName: string;
+    appId: string;
+    version: string;
+    buildNumber?: number | string;
+    description: string;
+    author: string;
+    homepage: string;
+    electronVersion: string;
+    electronMirror: string;
+    copyright: string;
+    projectDir: string;
+    files?: JsonObject;
+    appDistDir: string;
+    asarUnpack: string[];
+    smartUnpack: boolean;
+    extraResources: Array<ExtraResourceEntry>;
+    extraMetadata?: Record<string, unknown>;
+    onNodeModuleFile?: FileVisitor;
+    disableDefaultIgnoredFiles: boolean;
+    asar: {
+        path?: string;
+        unpackedDir?: string;
+    };
+    nativeModules: {
+        prebuiltRules?: (platform: NodePlatform, arch: Arch) => ReadonlyArray<PrebuiltModuleRule> | null | undefined;
+    };
+    mac: {
+        bundleName: string;
+        category: string;
+        iconFile?: string;
+        minimumSystemVersion: string;
+        urlSchemes: string[];
+        /** Extra Info.plist entries merged on top of the generated keys. */
+        plist: Record<string, unknown>;
+    };
+    win: {
+        iconFile?: string;
+        compressionLevel: number;
+        nsisVersion: string;
+        nsisResourcesVersion: string;
+        nsisCacheDir: string;
+        shortcutName: string;
+    };
+    linux: {
+        installDir: string;
+        iconDir: string;
+        iconSizes: number[];
+        debDepends: string[];
+        debRecommends: string;
+        maintainer: string;
+        mimeType: string;
+        desktopExtraFile?: string;
+    };
+    update: {
+        channel: string;
+        generateMetadata: boolean;
+        url: string;
+        extraArtifacts?: string[];
+    };
+    sign: {
+        enabled: boolean;
+        win?: {
+            enabled?: boolean;
+            hook?: (target: string, ctx: {
+                config: NormalizedConfig;
+                arch: Arch;
+                outputDir: string;
+                singleFile?: boolean;
+            }) => Promise<void> | void;
+        };
+        mac?: {
+            enabled?: boolean;
+            hook?: (target: string, ctx: {
+                config: NormalizedConfig;
+                arch: Arch;
+                outputDir: string;
+            }) => Promise<string> | string;
+        };
+    };
+}
+/** Overrides applied on top of the raw config during normalization. */
+export interface LoadConfigOverrides {
+    channel?: string;
+    signEnabled?: boolean;
+}
+/** Resolve the config path: an explicit path, or the first default candidate. */
+export declare function resolveConfigPath(explicitPath?: string): string;
+export declare function loadConfig(configPath: string, overrides?: LoadConfigOverrides): Promise<NormalizedConfig>;
+export declare function normalizeConfig(raw: Record<string, unknown>, overrides?: LoadConfigOverrides): NormalizedConfig;

package/dist/electron/dist-zip.d.ts

@@ -0,0 +1,18 @@
+import type { Arch, NodePlatform } from '../shared/platform.ts';
+interface ElectronZipConfig {
+    electronVersion: string;
+    electronMirror?: string;
+    checksums?: Record<string, string>;
+    cacheDir?: string;
+}
+/**
+ * Download (with cache) and read the Electron distribution zip for a target.
+ *
+ * Checksums are resolved from the electron package's checksums.json when
+ * present; otherwise the caller provides config.checksums keyed by archive name.
+ */
+export declare function downloadAndReadElectron(platform: NodePlatform, arch: Arch, config: ElectronZipConfig): Promise<{
+    zipPath: string;
+    entries: import("../archive/zip-reader.ts").ZipEntry[];
+}>;
+export {};

package/dist/electron/download.d.ts

@@ -0,0 +1,21 @@
+import { Arch, type NodePlatform } from '../shared/platform.ts';
+export interface DownloadElectronOptions {
+    version: string;
+    platform: NodePlatform;
+    arch: Arch;
+    mirror?: string;
+    cacheDir?: string;
+    expectedChecksum: string;
+}
+/**
+ * Compose the Electron distribution archive name for a target. The Electron
+ * release artifacts use "x64" rather than "amd64" for the x86-64 architecture,
+ * for example version "33.2.0" yields "electron-v33.2.0-win32-x64.zip".
+ */
+export declare function electronArchiveName(version: string, platform: NodePlatform, arch: Arch): string;
+/** Streams a file through sha256 and compares against the expected hex digest. */
+export declare function validateArchiveChecksum(archivePath: string, expectedChecksum: string): Promise<void>;
+/** Download a file with cache support and return the cached archive path. */
+export declare function downloadElectron({ version, platform, arch, mirror, cacheDir, expectedChecksum, }: DownloadElectronOptions): Promise<string>;
+/** Download a file while following redirects. No external dependencies. */
+export declare function downloadFile(url: string, destPath: string): Promise<void>;

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export type { PrebuiltModuleRule } from './asar/fileset/platform-fileset.ts';
+export { setPrebuiltDirResolver } from './asar/fileset/platform-fileset.ts';
+export type { LoadConfigOverrides, NormalizedConfig, } from './config/index.ts';
+export { loadConfig, normalizeConfig, resolveConfigPath } from './config/index.ts';
+export type { ExtraResourceEntry } from './packer/common/extra-resources.ts';
+export type { PackResult, PipelineOptions, TargetResult, TargetSpec } from './pipeline/pipeline.ts';
+export { runPack } from './pipeline/pipeline.ts';
+export { Arch, NodePlatform, nodeArchName, Platform } from './shared/platform.ts';
+export { buildBlockMap } from './update/blockmap.ts';
+export type { UpdateMetadataOptions } from './update/metadata.ts';
+export { generateUpdateMetadata } from './update/metadata.ts';

package/dist/packer/common/app-update-yml.d.ts

@@ -0,0 +1,5 @@
+import type { NormalizedConfig } from '../../config/index.ts';
+/** Derive the electron-updater cache directory name for a config. */
+export declare function getUpdaterCacheDirName(config: NormalizedConfig): string;
+/** Render the shared app-update.yml template. */
+export declare function renderAppUpdateYml(config: NormalizedConfig): Promise<string>;

package/dist/packer/common/extra-resources.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Extra-resource entry filtering, shared by the win/mac/linux packers.
+ */
+import { type Stats } from 'node:fs';
+import type { CollectDirectoryOptions } from '../../archive/tar.ts';
+import type { NormalizedConfig } from '../../config/index.ts';
+export interface ExtraResourceEntry {
+    from?: string;
+    to?: string;
+    required?: boolean;
+    exclude?: string[];
+    collectOptions?: CollectDirectoryOptions;
+}
+/** A resolved extra resource: source path, stat, and in-archive destination. */
+export interface ResolvedExtraResource {
+    res: ExtraResourceEntry;
+    srcPath: string;
+    srcStat: Stats;
+    destPath: string;
+}
+/**
+ * Resolve every configured extra resource into a source path plus stat.
+ * Missing optional sources are skipped; required sources throw via
+ * assertRequiredExtraResource.
+ */
+export declare function resolveExtraResources(config: NormalizedConfig): Promise<ResolvedExtraResource[]>;
+/**
+ * Check whether a directory entry (relative to the resource root) matches
+ * the resource's exclude list. A matched path or any path under it is excluded.
+ */
+export declare function isExtraResourcePathExcluded(resource: ExtraResourceEntry, relativePath: string): boolean;
+/**
+ * Ensures required extra resources exist before packaging.
+ * The optional hint callback returns an appended instruction telling the
+ * user how to obtain the missing resource (e.g. a project-specific
+ * download command); returning undefined falls back to the plain message.
+ * @throws when a required resource path is missing
+ */
+export declare function assertRequiredExtraResource(projectDir: string, res: ExtraResourceEntry, missingHint?: (from: string) => string | undefined): void;

package/dist/packer/common/staging.d.ts

@@ -0,0 +1,3 @@
+import type { Arch } from '../../shared/platform.ts';
+export declare function createStagingDir(outputDir: string, label: string, arch: Arch): Promise<string>;
+export declare function removeStagingDir(stagingDir: string): Promise<void>;

package/dist/packer/common/template.d.ts

@@ -0,0 +1,2 @@
+export declare function getTemplatesDir(...segments: string[]): string;
+export declare function renderTemplate(template: string, replacements: Record<string, string | number>): string;

package/dist/packer/linux/linux.d.ts

@@ -0,0 +1,2 @@
+import type { PackerContext } from '../../pipeline/targets.ts';
+export declare function packLinux({ config, arch, outputDir, asarPath, unpackedDir, }: PackerContext): Promise<string>;

package/dist/packer/mac/mac.d.ts

@@ -0,0 +1,23 @@
+import type { Archiver } from 'archiver';
+import type { NormalizedConfig } from '../../config/index.ts';
+import type { PackerContext } from '../../pipeline/targets.ts';
+import { type ExtraResourceEntry } from '../common/extra-resources.ts';
+interface MacBundleIdentity {
+    /** Bundle directory name, for example "MyApp.app". */
+    appName: string;
+    /** On-disk bundle base name. */
+    bundleName: string;
+    /** User-visible product name. */
+    displayName: string;
+    executableName: string;
+    helperName: string;
+    /** Helper name with unsafe characters removed. */
+    sanitizedHelperName: string;
+}
+export declare function packMac({ config, arch, outputDir, asarPath, unpackedDir, }: PackerContext): Promise<string>;
+/** Derive bundle identity (app name, executable, helper names) from config. */
+export declare function resolveMacBundleIdentity(config: NormalizedConfig): MacBundleIdentity;
+/** Normalize an archive entry mode to executable / regular file bits. */
+export declare function normalizeMacArchiveFileMode(sourceMode: string | number): number;
+export declare function addDirectoryToArchive(archive: Archiver, dirPath: string, archivePath: string, resource?: ExtraResourceEntry, relativePath?: string): void;
+export {};

package/dist/packer/win/nsis.d.ts

@@ -0,0 +1,24 @@
+import type { NormalizedConfig } from '../../config/index.ts';
+export declare function getNsisTemplatesDir(): string;
+export declare function prepareNsisToolchain(projectDir: string, winConfig: NormalizedConfig['win']): Promise<{
+    nsisDir: string;
+    nsisResourcesDir: string;
+}>;
+/**
+ * Assemble the NSIS script header: include paths, plugin directories,
+ * and localized messages.
+ */
+export declare function buildNsisScriptHeader({ nsisIncludeDir, nsisPluginsDir, pluginArch, nsisTemplatesDir, stagingDir, }: {
+    nsisIncludeDir: string;
+    nsisPluginsDir: string;
+    pluginArch: string;
+    nsisTemplatesDir: string;
+    stagingDir: string;
+}): Promise<string>;
+export declare function executeMakensis({ nsisDir, defines, commands, script, cwd, }: {
+    nsisDir: string;
+    defines: Record<string, string | null>;
+    commands: Record<string, unknown>;
+    script: string;
+    cwd: string;
+}): Promise<void>;

package/dist/packer/win/resedit.d.ts

@@ -0,0 +1,5 @@
+import type { NormalizedConfig } from '../../config/index.ts';
+export declare function editExeResources(exePath: string, { iconPath, config }: {
+    iconPath: string | null;
+    config: NormalizedConfig;
+}): Promise<void>;

package/dist/packer/win/toolchain.d.ts

@@ -0,0 +1,8 @@
+export declare function downloadAndExtract7z({ url, sha512, name, cacheDir, targetDir, validateExtracted, }: {
+    url: string;
+    sha512: string;
+    name: string;
+    cacheDir: string;
+    targetDir: string;
+    validateExtracted: (dir: string) => boolean;
+}): Promise<void>;

package/dist/packer/win/win.d.ts

@@ -0,0 +1,12 @@
+import type { NormalizedConfig } from '../../config/index.ts';
+import type { PackerContext } from '../../pipeline/targets.ts';
+export declare function packWin({ config, arch, outputDir, asarPath, unpackedDir, }: PackerContext): Promise<string>;
+/** Derive the installer .exe filename from the distribution naming contract. */
+export declare function buildWindowsInstallerFilename(config: NormalizedConfig): string;
+/** Derive the Windows package identity (install dir, shortcut, updater cache). */
+export declare function resolveWindowsPackageIdentity(config: NormalizedConfig): {
+    appFilename: string;
+    productFilename: string;
+    shortcutName: string;
+    updaterCacheDirName: string;
+};

package/dist/pipeline/pipeline.d.ts

@@ -0,0 +1,41 @@
+import type { NormalizedConfig } from '../config/index.ts';
+import type { Arch, Platform } from '../shared/platform.ts';
+import type { FileSet } from '../shared/types.ts';
+import { type PackTarget } from './targets.ts';
+export interface PackResult {
+    ok: boolean;
+    outputDir: string;
+    targets: TargetResult[];
+}
+export interface PipelineOptions {
+    platforms: Platform[];
+    arches: Arch[];
+    output: string;
+    dryRun: boolean;
+    onTargetComplete?: (result: TargetResult) => void;
+}
+export interface TargetResult {
+    platform: Platform;
+    arch: Arch;
+    output?: string;
+    error?: string;
+}
+export interface TargetSpec {
+    platform: Platform;
+    arches?: Arch[];
+    config?: (config: NormalizedConfig) => NormalizedConfig;
+}
+interface CollectedProjectFiles {
+    appFileSet: FileSet;
+    nmFileSets: FileSet[];
+    transformer: (file: string) => Promise<string | null> | string | null;
+}
+interface SharedState {
+    collectPromise?: Promise<CollectedProjectFiles>;
+}
+export declare function resolveAsarForTarget(target: PackTarget, config: NormalizedConfig, outputDir: string, shared: SharedState): Promise<{
+    asarPath: string;
+    unpackedDir: string | undefined;
+}>;
+export declare function runPack(config: NormalizedConfig, options: PipelineOptions, targetSpecs?: TargetSpec[]): Promise<PackResult>;
+export {};

package/dist/pipeline/targets.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Target resolution: maps (platform, arch) pairs to packer implementations.
+ */
+import type { NormalizedConfig } from '../config/index.ts';
+import type { Arch, Platform } from '../shared/platform.ts';
+import type { PipelineOptions, TargetSpec } from './pipeline.ts';
+export interface PackerContext {
+    config: NormalizedConfig;
+    arch: Arch;
+    outputDir: string;
+    asarPath?: string;
+    unpackedDir?: string;
+}
+/** A single (platform, arch) packaging unit. */
+export interface PackTarget {
+    platform: Platform;
+    arch: Arch;
+    run: (asar: {
+        asarPath?: string;
+        unpackedDir?: string;
+    }) => Promise<string>;
+}
+export declare function runPlatformPackers({ config, options, outputDir, targetSpecs, }: {
+    config: NormalizedConfig;
+    options: PipelineOptions;
+    outputDir: string;
+    targetSpecs?: TargetSpec[];
+}): PackTarget[];

package/dist/shared/hash.d.ts

@@ -0,0 +1,2 @@
+/** Hash a file's contents with the given algorithm and digest encoding. */
+export declare function hashFile(filePath: string, algorithm?: 'sha256' | 'sha512', encoding?: 'hex' | 'base64'): string;

package/dist/shared/logger.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Logging facade. All output is written through process.stdout.write or
+ * process.stderr.write; quiet mode suppresses every channel.
+ */
+import type { Arch, Platform } from './platform.ts';
+interface LoggerOptions {
+    quiet?: boolean;
+}
+interface BannerSummary {
+    platforms: Platform[];
+    arches: Arch[];
+}
+interface TargetResult {
+    platform: Platform;
+    arch: Arch;
+    output?: string;
+    error?: string;
+}
+interface SummaryResult {
+    targets: TargetResult[];
+}
+/** Project identity fields shown in the banner; any config object with these fields works. */
+export interface BannerInput {
+    productName: string;
+    version: string;
+    electronVersion: string;
+}
+export interface Logger {
+    info: (message: string) => void;
+    warn: (message: string) => void;
+    error: (message: string) => void;
+    step: (label: string, message: string) => void;
+    banner: (project: BannerInput, summary: BannerSummary) => void;
+    summary: (result: SummaryResult) => void;
+}
+export declare function createLogger(options?: LoggerOptions): Logger;
+/** Shared default logger instance, used by packer/collector/util modules. */
+export declare const logger: Logger;
+export {};

package/dist/shared/platform.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Cross-layer platform vocabulary: target platforms, architectures, and
+ * Node.js host platforms. Zero project dependencies; both config and the
+ * asar domain consume these enums.
+ */
+export declare enum Platform {
+    WIN = "win",
+    MAC = "mac",
+    LINUX = "linux"
+}
+export declare enum Arch {
+    AMD64 = "amd64",
+    ARM64 = "arm64"
+}
+export declare enum NodePlatform {
+    WIN32 = "win32",
+    DARWIN = "darwin",
+    LINUX = "linux"
+}
+export declare function nodeArchName(arch: Arch): 'x64' | 'arm64';
+/**
+ * Narrow the host's `process.platform` to NodePlatform.
+ * Throws on unsupported hosts (node_modules collection is only defined
+ * for win32 / darwin / linux).
+ */
+export declare function nodePlatformOf(host: NodeJS.Platform): NodePlatform;

package/dist/shared/types.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Zero-dependency shared types.
+ *
+ * This file may only import from `node:` builtins and external type
+ * packages — never from project modules. Every other layer depends on
+ * `shared/`, which keeps type-only dependencies acyclic at the module level.
+ */
+import type { Stats } from 'node:fs';
+/** The kind of an asar-storable entry. */
+export declare enum EntryKind {
+    FILE = "file",
+    DIRECTORY = "directory",
+    LINK = "link"
+}
+/** A plain JSON object: arbitrary string keys, JSON-compatible values. */
+export type JsonObject = Record<string, unknown>;
+/** A logical file set: an absolute source dir plus the collected files. */
+export interface FileSet {
+    src: string;
+    destination: string;
+    files: string[];
+    metadata: Map<string, FileStat>;
+}
+/** File filter predicate used across collectors. */
+export type FileFilter = (file: string, stat: FileStat) => boolean;
+/**
+ * Callback invoked for each collected node_modules file; returning true
+ * forces the file to be included even if it matches default exclusions.
+ */
+export type FileVisitor = (file: string) => boolean;
+/**
+ * Collected entry metadata: the entry kind plus the module metadata that
+ * the collectors attach. Pure data with no behavior.
+ */
+export interface FileStat {
+    type: EntryKind;
+    size: number;
+    mode: number;
+    /** Real on-disk source path when the packed file differs from the logical path. */
+    realFilePath?: string;
+    /** Name of the node module the file belongs to. */
+    moduleName?: string;
+    /** Root directory of the owning module. */
+    moduleRootPath?: string;
+    /** Full path relative to the module root. */
+    moduleFullFilePath?: string;
+    /** Symlink target relative to the module root. */
+    relativeLink?: string;
+    /** Symlink target relative to the link's directory. */
+    linkRelativeToFile?: string;
+}
+/** A resolved production dependency reported by the collector. */
+export interface DependencyEntry {
+    name: string;
+    dir: string;
+    dependencies?: DependencyEntry[];
+}
+/** A parsed minimatch pattern (from the `minimatch` package). */
+export interface MinimatchPattern {
+    match: (p: string, partial?: boolean) => boolean;
+    set: Array<Array<string | object | symbol>>;
+    negate: boolean;
+}
+/**
+ * Map an fs stat result to its entry kind, or null for special entries
+ * (sockets, FIFOs, devices) that the asar format cannot store.
+ */
+export declare function entryKind(stat: Stats): EntryKind | null;

package/dist/update/blockmap.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Pure-JavaScript blockmap generator using Rabin fingerprinting.
+ * Ported from electron-builder v26.15.2 (app-builder-lib/out/targets/blockmap/blockmap.js),
+ * which replaced the Go-based app-builder.exe blockmap command.
+ *
+ * The output format is identical (blockmap v2 JSON), so the generated
+ * .blockmap files are fully compatible with electron-updater.
+ */
+export declare function buildBlockMap(inFile: string, compressionFormat: string, outFile?: string | null): Promise<{
+    sha512: string;
+    size: number;
+    blockMapSize?: number;
+}>;

package/dist/update/metadata.d.ts

@@ -0,0 +1,20 @@
+import { NodePlatform } from '../shared/platform.ts';
+export interface UpdateMetadataOptions {
+    filePath: string;
+    version: string;
+    outputDir: string;
+    platform: NodePlatform;
+    blockMapSize?: number;
+    channel?: string;
+    extraFiles?: string[];
+}
+/**
+ * Derive the update channel from a semver prerelease suffix
+ * (for example, 1.2.3-beta.1 yields "beta").
+ */
+export declare function getUpdateChannel(version: string, explicitChannel?: string, defaultChannel?: string): string;
+export declare function getUpdateMetadataFileName(version: string, explicitChannel?: string, platform?: NodePlatform, defaultChannel?: string): string;
+export declare function generateUpdateMetadata({ filePath, version, outputDir, platform, blockMapSize, channel, extraFiles, }: UpdateMetadataOptions): {
+    metadataPath: string;
+    metadataFileName: string;
+} | null;

package/dist/update/version.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Convert a semver string into the four-part numeric build version.
+ * NSIS VIProductVersion and PE version resources require the X.X.X.X format.
+ * The fourth segment prefers: explicit buildNumber param > prerelease number
+ * in the version string > CI build number (only when CI=true).
+ */
+export declare function getBuildVersion(version: string, buildNumber?: number | string): string;

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "cross-packer",
+  "version": "0.1.0",
+  "description": "Cross-platform Electron app packager — assemble Windows (NSIS), macOS (.app/.zip) and Linux (.deb) artifacts on any host OS, without electron-builder.",
+  "type": "module",
+  "private": false,
+  "license": "AGPL-3.0-or-later",
+  "author": "SgDylan",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Sg4Dylan/cross-packer.git"
+  },
+  "homepage": "https://github.com/Sg4Dylan/cross-packer#readme",
+  "bugs": "https://github.com/Sg4Dylan/cross-packer/issues",
+  "engines": {
+    "node": ">=20"
+  },
+  "bin": {
+    "cross-packer": "src/cli.ts"
+  },
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "default": "./src/index.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@noble/hashes": "^2.4.0",
+    "7zip-bin": "^5.2.0",
+    "archiver": "^8.0.0",
+    "chromium-pickle-js": "^0.2.0",
+    "fs-extra": "^11.4.0",
+    "js-yaml": "^5.4.2",
+    "jszip": "^3.10.2",
+    "minimatch": "^10.2.6",
+    "plist": "5.0.0",
+    "resedit": "^3.1.0",
+    "tar": "^7.5.22"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.5.13",
+    "@types/archiver": "^8.0.0",
+    "@types/fs-extra": "^11.0.4",
+    "@typescript/native-preview": "7.0.0-dev.20260707.2",
+    "electron": "42.7.1",
+    "tsx": "^4.23.13"
+  },
+  "files": [
+    "src",
+    "dist",
+    "templates",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "tsx --test \"test/*.test.ts\"",
+    "build": "tsgo -p tsconfig.build.json",
+    "lint": "biome check .",
+    "lint:fix": "biome check --write .",
+    "format": "biome format --write .",
+    "typecheck": "npx tsgo --noEmit"
+  },
+  "keywords": [
+    "electron",
+    "packaging",
+    "nsis",
+    "deb",
+    "cross-platform"
+  ]
+}