@gtkx/cli 1.6.0 → 2.0.0-beta.1

package/src/codegen/run-codegen.ts

@@ -1,29 +1,20 @@
 import { runCodegen as runCodegenCore } from "@gtkx/codegen";
-import {
-    getShadowingStorePaths,
-    LIBRARIES_WILDCARD,
-    redundantLibraries,
-    sweepProjectStaging,
-} from "@gtkx/codegen/internal";
+import { getShadowingStorePaths, sweepProjectStaging } from "@gtkx/codegen/internal";
 import { type Config, loadConfig } from "@gtkx/config";
 import {
     isAgentRulesEnabled,
-    type ResolvedFuture,
     resolveElementComponents,
     resolveElementProps,
-    resolveFuture,
     resolveLazyElements,
     resolveOmittedProps,
-    unknownFutureKeys,
 } from "@gtkx/config/internal";
-import { info, warn } from "@gtkx/utils";
+import { info } from "@gtkx/utils";
 import { existsSync, rmSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { resolveCatalogProject, synchronizeCatalogs } from "../i18n/catalogs.js";
 import { extractSourceCatalog } from "../i18n/source-messages.js";
-import { emitI18nTypes } from "../i18n/types.js";
+import { clearI18nTypes, emitI18nTypes } from "../i18n/types.js";
 import { upsertAgentRules } from "../internal/agent-rules.js";
-import { resolveDataDir } from "../internal/data-dir.js";
 import { discoverSourceFiles } from "../internal/source-imports.js";
 import { emitSchemaEnv } from "../settings/schema.js";
 import { type CodegenInputs, isCodegenStale, resolveCodegenInputs } from "./freshness.js";
@@ -48,12 +39,10 @@ type RunCodegenResult = {
     isRegenerated: boolean;
     namespaces: number;
     intrinsicElements: number;
-    notices: string[];
     duration: number;
-    girPath?: string[] | undefined;
-    configFile?: string | undefined;
-    libraries?: string[] | undefined;
-    future?: string[] | undefined;
+    girPath: string[];
+    configFile: string;
+    libraries: string[];
     reference?: ReferenceResult | undefined;
 };
 
@@ -62,7 +51,6 @@ type CodegenOptionsInput = {
     libraries: string[];
     girPath: string[];
     elements: Config["elements"];
-    future: ResolvedFuture;
 };
 
 type PreparedCodegen = CodegenInputs & { isForced: boolean };
@@ -73,14 +61,6 @@ type EnsureGeneratedOptions = {
     shouldPreserveI18nMetadata?: boolean | undefined;
 };
 
-type RunOptionsInput = {
-    root: string;
-    mode: string | undefined;
-    inputs: CodegenInputs | null;
-    resolved: LoadedConfig;
-    shouldPreserveI18nMetadata: boolean | undefined;
-};
-
 const GIR_PATH_MISSING_MESSAGE =
     "No GIR search paths available. Install gobject-introspection " +
     "(Linux: `sudo dnf install gobject-introspection-devel` or `sudo apt install libgirepository1.0-dev`), " +
@@ -97,14 +77,9 @@ const removeShadowingStores = (cwd: string): void => {
     removeStores(getShadowingStorePaths(cwd));
 };
 
-const codegenOptions = ({ store, libraries, girPath, elements, future }: CodegenOptionsInput) => ({
+const codegenOptions = ({ store, libraries, girPath, elements }: CodegenOptionsInput) => ({
     libraries,
     girPath,
-    isByteArrayTyped: future.isByteArrayTyped,
-    isValueUnwrapped: future.isValueUnwrapped,
-    isFinishTrimmed: future.isFinishTrimmed,
-    isInoutInPlace: future.isInoutInPlace,
-    isTreeShaken: future.isTreeShaken,
     gi: {
         storeDir: store.giStoreDir,
         linkDir: store.giLinkDir,
@@ -118,93 +93,30 @@ const codegenOptions = ({ store, libraries, girPath, elements, future }: Codegen
                     linkDir: store.jsxLinkDir,
                     version: store.react.version,
                 },
-    reactSubexports: store.react?.subexports ?? [],
     userComponents: resolveElementComponents(elements),
     userProps: resolveElementProps(elements),
     userLazyElements: resolveLazyElements(elements),
     userOmittedProps: resolveOmittedProps(elements),
 });
 
-const enabledFutureFlags = (config: Config): string[] => {
-    const unknown: Set<string> = new Set(unknownFutureKeys(config.future));
-
-    return Object.entries(config.future ?? {})
-        .filter(([name, value]) => value === true && !unknown.has(name))
-        .map(([name]) => name);
-};
-
-const disabledCodegenResult = (configFile: string, notices: string[]): RunCodegenResult => ({
+const disabledCodegenResult = (configFile: string): RunCodegenResult => ({
     isRegenerated: false,
     namespaces: 0,
     intrinsicElements: 0,
-    notices,
     duration: 0,
     girPath: [],
     configFile,
     libraries: [],
 });
 
-const warnNotices = (notices: string[]): void => {
-    for (const notice of notices) {
-        warn(notice);
-    }
-};
-
-const unknownFutureNotice = (keys: string[]): string[] => {
-    if (keys.length === 0) {
-        return [];
-    }
-
-    return [
-        `gtkx.config.ts: \`future\` has no ${keys.join(", ")} flag, so the key is ignored. Check it against ` +
-        "the flags the configuration guide lists.",
-    ];
-};
-
-const redundantLibraryNotice = (entries: string[]): string[] => {
-    if (entries.length === 0) {
-        return [];
-    }
-
-    return [
-        `gtkx.config.ts: \`future.v2DefaultLibraries\` binds ${entries.join(", ")} on its own, so naming them ` +
-        "in `libraries` changes nothing. Drop them; naming them becomes a configuration error in GTKX 2.0.",
-    ];
-};
-
-const wildcardLibrariesNotice = (libraries: Config["libraries"]): string[] => {
-    if (libraries !== LIBRARIES_WILDCARD) {
-        return [];
-    }
-
-    return [
-        'gtkx.config.ts: `libraries: "*"` binds whatever the build host happens to have installed, so the ' +
-        "store changes with the machine. Instead, list the libraries the project needs; the wildcard is " +
-        "removed in GTKX 2.0.",
-    ];
-};
-
-const configNotices = (config: Config, future: ResolvedFuture): string[] => [
-    ...unknownFutureNotice(unknownFutureKeys(config.future)),
-    ...wildcardLibrariesNotice(config.libraries),
-    ...redundantLibraryNotice(redundantLibraries(config.libraries, future.isAdwaitaDefault)),
-];
-
-const regeneratedStorePaths = (store: CodegenStore): string[] => {
-    if (store.react === null) {
-        return [store.giStoreDir, store.giLinkDir];
-    }
-
-    return [store.giStoreDir, store.giLinkDir, store.jsxStoreDir, store.jsxLinkDir];
-};
-
 const clearGeneratedStores = (store: CodegenStore): void => {
-    removeStores(regeneratedStorePaths(store));
+    removeStores(
+        store.react === null
+            ? [store.giStoreDir, store.giLinkDir]
+            : [store.giStoreDir, store.giLinkDir, store.jsxStoreDir, store.jsxLinkDir],
+    );
 };
 
-const resolveLoadedConfig = async (options: RunCodegenOptions, cwd: string): Promise<LoadedConfig> =>
-    options.resolved ?? (await loadConfig(cwd, { mode: options.mode }));
-
 const prepareCodegen = (options: RunCodegenOptions, cwd: string, config: Config): PreparedCodegen => {
     const { girPath, libraries, store } = options.inputs ?? resolveCodegenInputs(cwd, config);
 
@@ -219,17 +131,14 @@ const prepareCodegen = (options: RunCodegenOptions, cwd: string, config: Config)
 
 const runCodegen = async (options: RunCodegenOptions = {}): Promise<RunCodegenResult> => {
     const cwd = options.cwd ?? process.cwd();
-    const { config, configFile } = await resolveLoadedConfig(options, cwd);
-    const future = resolveFuture(config.future);
-    const configured = configNotices(config, future);
-    warnNotices(configured);
+    const { config, configFile } = options.resolved ?? (await loadConfig(cwd, { mode: options.mode }));
     await syncI18n(cwd, config.applicationId, options.shouldPreserveI18nMetadata);
-    syncSchemaEnv(cwd, future.isResourceImported);
+    emitSchemaEnv(cwd);
 
     if (config.codegen === false) {
         removeShadowingStores(cwd);
 
-        return disabledCodegenResult(configFile, configured);
+        return disabledCodegenResult(configFile);
     }
 
     const { girPath, libraries, store, isForced } = prepareCodegen(options, cwd, config);
@@ -239,35 +148,28 @@ const runCodegen = async (options: RunCodegenOptions = {}): Promise<RunCodegenRe
     }
 
     const result = await runCodegenCore({
-        ...codegenOptions({ store, libraries, girPath, elements: config.elements, future }),
+        ...codegenOptions({ store, libraries, girPath, elements: config.elements }),
         isForced,
     });
 
-    warnNotices(result.notices);
-    const notices = [...configured, ...result.notices];
     const reference = await writeReference({ root: cwd, config, girPath, libraries, isForced });
-    syncAgentRules(cwd, config);
+
+    if (isAgentRulesEnabled(config)) {
+        upsertAgentRules(cwd);
+    }
 
     return {
         isRegenerated: result.isRegenerated,
         namespaces: result.namespaces,
         intrinsicElements: result.intrinsicElements,
-        notices,
         duration: result.duration,
         girPath,
         configFile,
         libraries,
-        future: enabledFutureFlags(config),
         reference,
     };
 };
 
-const syncAgentRules = (root: string, config: Config): void => {
-    if (isAgentRulesEnabled(config)) {
-        upsertAgentRules(root);
-    }
-};
-
 const syncI18n = async (
     root: string,
     applicationId: string,
@@ -276,16 +178,16 @@ const syncI18n = async (
     const project = resolveCatalogProject(root, applicationId);
 
     if (project === null) {
-        emitI18nTypes(root, [], false);
+        clearI18nTypes(root);
 
         return;
     }
 
     const srcDir = join(root, "src");
     const sourceFiles = discoverSourceFiles(existsSync(srcDir) ? srcDir : root);
-    const catalog = await extractSourceCatalog(project, sourceFiles, shouldPreserveMetadataMessages);
+    await extractSourceCatalog(project, sourceFiles, shouldPreserveMetadataMessages);
     synchronizeCatalogs(project);
-    emitI18nTypes(root, catalog.messages);
+    await emitI18nTypes(root);
 };
 
 const isCodegenDisabled = async (cwd: string, mode?: string): Promise<boolean> => {
@@ -298,11 +200,6 @@ const isCodegenDisabled = async (cwd: string, mode?: string): Promise<boolean> =
     }
 };
 
-const syncSchemaEnv = (cwd: string, isV2ResourceImports = false): void => {
-    const dataDir = isV2ResourceImports ? null : resolveDataDir(cwd);
-    emitSchemaEnv(cwd, dataDir, isV2ResourceImports);
-};
-
 const resolveInputsOrNull = (cwd: string, config: Config): CodegenInputs | null => {
     try {
         return resolveCodegenInputs(cwd, config);
@@ -321,20 +218,6 @@ const maybeAnnounceStale = (shouldAnnounce: boolean | undefined, inputs: Codegen
     }
 };
 
-const getRunOptions = ({
-    root,
-    mode,
-    inputs,
-    resolved,
-    shouldPreserveI18nMetadata,
-}: RunOptionsInput): RunCodegenOptions => {
-    if (inputs === null) {
-        return { cwd: root, mode, resolved, shouldPreserveI18nMetadata };
-    }
-
-    return { cwd: root, mode, inputs, resolved, shouldPreserveI18nMetadata };
-};
-
 const isPreflightSkipped = (options: EnsureGeneratedOptions): boolean =>
     options.shouldAnnounce === true && process.env.GTKX_DISABLE_PREFLIGHT === "1";
 
@@ -355,13 +238,13 @@ const generate = async (context: CodegenContext, options: EnsureGeneratedOptions
     maybeAnnounceStale(options.shouldAnnounce, inputs);
     const resolved = { config: context.config, configFile: context.configFile };
 
-    const result = await runCodegen(getRunOptions({
-        root: context.root,
+    const result = await runCodegen({
+        cwd: context.root,
         mode: options.mode,
-        inputs,
         resolved,
         shouldPreserveI18nMetadata: options.shouldPreserveI18nMetadata,
-    }));
+        ...(inputs !== null && { inputs }),
+    });
 
     return result.isRegenerated;
 };

package/src/codegen/store-resolver.ts

@@ -1,6 +1,6 @@
 import { resolveStore } from "@gtkx/codegen";
 import { type Config, loadConfig } from "@gtkx/config";
-import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { existsSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 import { pathToFileURL } from "node:url";
@@ -16,39 +16,23 @@ type CodegenStore = {
 
 type CodegenReactPackage = {
     version: string;
-    subexports: string[];
 };
 
-type ResolvedPackage = { dir: string; version: string };
-
 type CodegenContext = {
     root: string;
     config: Config;
     configFile: string;
 };
 
-const readVersion = (packageJsonPath: string): string => {
-    const parsed = JSON.parse(readFileSync(packageJsonPath, "utf8")) as { version?: string };
-
-    return parsed.version ?? "0.0.0";
-};
-
-const resolvePackage = (require: NodeJS.Require, dir: string, packageName: string): ResolvedPackage | null => {
+const hasPackage = (require: NodeJS.Require, dir: string, packageName: string): boolean => {
     try {
-        const real = realpathSync(require.resolve(`${packageName}/package.json`));
+        require.resolve(`${packageName}/package.json`);
 
-        return { dir: dirname(real), version: readVersion(real) };
+        return true;
     } catch {
         const unscoped = packageName.replace(/^@[^/]+\//, "");
-        const workspacePkg = join(dir, "packages", unscoped, "package.json");
-
-        if (!existsSync(workspacePkg)) {
-            return null;
-        }
-
-        const real = realpathSync(workspacePkg);
 
-        return { dir: dirname(real), version: readVersion(real) };
+        return existsSync(join(dir, "packages", unscoped, "package.json"));
     }
 };
 
@@ -57,12 +41,12 @@ const siblingStore = (giDir: string): string => join(dirname(giDir), "jsx");
 const resolveCodegenStore = (dir: string): CodegenStore => {
     const require = createRequire(pathToFileURL(join(dir, "__gtkx_resolver__.js")).href);
 
-    if (resolvePackage(require, dir, "@gtkx/native") === null) {
+    if (!hasPackage(require, dir, "@gtkx/native")) {
         throw new Error("Cannot resolve @gtkx/native from the project; is it installed?");
     }
 
     const store = resolveStore(dir);
-    const hasReactRuntime = resolvePackage(require, dir, "react") !== null;
+    const hasReactRuntime = hasPackage(require, dir, "react");
 
     return {
         giStoreDir: store.gi.storeDir,
@@ -72,7 +56,7 @@ const resolveCodegenStore = (dir: string): CodegenStore => {
         runtimeVersion: store.gi.version,
         react:
             hasReactRuntime && store.jsx !== null
-                ? { version: store.jsx.version, subexports: store.reactSubexports }
+                ? { version: store.jsx.version }
                 : null,
     };
 };

package/src/commands/docs.ts

@@ -1,10 +1,10 @@
 import { mergeOmittedProps, resolveGirPath, resolveLibraries } from "@gtkx/codegen";
 import { writeDocs } from "@gtkx/codegen/internal";
 import { loadConfig } from "@gtkx/config";
-import { resolveFuture, resolveOmittedProps } from "@gtkx/config/internal";
-import { info } from "@gtkx/utils";
+import { resolveOmittedProps } from "@gtkx/config/internal";
+import { info, isPathInside } from "@gtkx/utils";
 import { defineCommand } from "citty";
-import { isAbsolute, relative, resolve, sep } from "node:path";
+import { resolve } from "node:path";
 import { resolveDocsElements } from "../internal/docs-elements.js";
 import { cwdArg, resolveCwd } from "../internal/entry-arg.js";
 
@@ -57,8 +57,7 @@ const docs = defineCommand({
             );
         }
 
-        const future = resolveFuture(config.future);
-        const libraries = resolveLibraries(config.libraries, girPath, future.isAdwaitaDefault);
+        const libraries = resolveLibraries(config.libraries);
         const startedAt = Date.now();
         const outDir = resolveOutDir(cwd, args.out);
         const builtin = await resolveDocsElements(cwd);
@@ -71,11 +70,6 @@ const docs = defineCommand({
             props: builtin.props,
             omittedProps: mergeOmittedProps(builtin.omittedProps, resolveOmittedProps(config.elements)),
             isForced: args.force,
-            isByteArrayTyped: future.isByteArrayTyped,
-            isValueUnwrapped: future.isValueUnwrapped,
-            isFinishTrimmed: future.isFinishTrimmed,
-            isInoutInPlace: future.isInoutInPlace,
-            isTreeShaken: future.isTreeShaken,
         });
 
         if (!isRegenerated) {
@@ -93,12 +87,6 @@ const docs = defineCommand({
     },
 });
 
-const isBelow = (parent: string, child: string): boolean => {
-    const path = relative(parent, child);
-
-    return path !== "" && path !== ".." && !path.startsWith(`..${sep}`) && !isAbsolute(path);
-};
-
 const outDirReason = (cwd: string, out: string, outDir: string): string => {
     if (out.trim() === "") {
         return "it was empty, which names the project root itself";
@@ -114,7 +102,7 @@ const outDirReason = (cwd: string, out: string, outDir: string): string => {
 const resolveOutDir = (cwd: string, out: string): string => {
     const outDir = out.trim() === "" ? cwd : resolve(cwd, out);
 
-    if (isBelow(cwd, outDir)) {
+    if (isPathInside(cwd, outDir)) {
         return outDir;
     }
 

package/src/deploy/freedesktop/copyright.ts

@@ -1,6 +1,6 @@
-import { readFileSync } from "node:fs";
 import type { DeploySettings, Notice, NoticeSection } from "../types.js";
 import { BUNDLE_FILENAME } from "../../vite-plugins/esm-extension.js";
+import { readLicenseText } from "../notices/text.js";
 
 type FileStanza = {
     settings: DeploySettings;
@@ -30,18 +30,6 @@ const foldedField = (name: string, lines: string[]): string[] => {
     return first === undefined ? [] : [`${name}: ${first}`, ...rest.map((line) => indentLine(line))];
 };
 
-const licenseText = (licenseFile: string | null): string | null => {
-    if (licenseFile === null) {
-        return null;
-    }
-
-    try {
-        return readFileSync(licenseFile, "utf8").trimEnd();
-    } catch {
-        return null;
-    }
-};
-
 const shortName = (license: string): string =>
     license
         .replaceAll(SPDX_GROUPING, " ")
@@ -159,7 +147,7 @@ const applicationStanza = (settings: DeploySettings, text: string | null): strin
 ];
 
 const renderCopyright = (settings: DeploySettings, sections: NoticeSection[]): string => {
-    const own = licenseText(settings.paths.licenseFile);
+    const own = settings.paths.licenseFile === null ? null : readLicenseText(settings.paths.licenseFile);
     const reproduced: Set<string> = new Set(own === null ? [] : [own]);
 
     const stanzas = filePatterns(sections).flatMap((files) =>

package/src/deploy/freedesktop/xml.ts

@@ -1,3 +1,5 @@
+import XMLBuilder from "fast-xml-builder";
+
 type XmlNode = {
     tag: string;
     attributes?: Record<string, string>;
@@ -5,23 +7,26 @@ type XmlNode = {
     text?: string;
 };
 
-const XML_DECLARATION = '<?xml version="1.0" encoding="UTF-8"?>';
-const INDENT = " ".repeat(4);
+type OrderedNode = Record<string, unknown>;
 
-const ESCAPES: Record<string, string> = {
-    '"': "&quot;",
-    "&": "&amp;",
-    "<": "&lt;",
-    ">": "&gt;",
-};
+const XML_ENCODING = ["UTF", "8"].join("-");
 
-const escapeXml = (value: string): string =>
-    value.replaceAll(/["&<>]/g, (character) => ESCAPES[character] ?? character);
+const builder = new XMLBuilder({
+    format: true,
+    ignoreAttributes: false,
+    indentBy: " ".repeat(4),
+    preserveOrder: true,
+    suppressEmptyNode: true,
+});
 
-const renderAttributes = (attributes: Record<string, string> | undefined): string =>
-    Object.entries(attributes ?? {})
-        .map(([key, value]) => ` ${key}="${escapeXml(value)}"`)
-        .join("");
+const orderedNode = (node: XmlNode): OrderedNode => ({
+    [node.tag]: node.text === undefined
+        ? (node.children ?? []).map((child) => orderedNode(child))
+        : [{ "#text": node.text }],
+    ...(node.attributes && {
+        ":@": Object.fromEntries(Object.entries(node.attributes).map(([key, value]) => [`@_${key}`, value])),
+    }),
+});
 
 const element = (tag: string, attributes: Record<string, string>, children: XmlNode[]): XmlNode => ({
     tag,
@@ -31,23 +36,10 @@ const element = (tag: string, attributes: Record<string, string>, children: XmlN
 
 const text = (tag: string, value: string): XmlNode => ({ tag, text: value });
 
-const renderNode = (node: XmlNode, depth: number): string[] => {
-    const padding = INDENT.repeat(depth);
-    const open = `${padding}<${node.tag}${renderAttributes(node.attributes)}`;
-
-    if (node.text !== undefined) {
-        return [`${open}>${escapeXml(node.text)}</${node.tag}>`];
-    }
-
-    const children = node.children ?? [];
-
-    if (children.length === 0) {
-        return [`${open}/>`];
-    }
-
-    return [`${open}>`, ...children.flatMap((child) => renderNode(child, depth + 1)), `${padding}</${node.tag}>`];
-};
-
-const renderDocument = (root: XmlNode): string => [XML_DECLARATION, ...renderNode(root, 0), ""].join("\n");
+const renderDocument = (root: XmlNode): string =>
+    `${builder.build([
+        { "?xml": [{ "#text": "" }], ":@": { "@_version": "1.0", "@_encoding": XML_ENCODING } },
+        orderedNode(root),
+    ])}\n`;
 
 export { element, renderDocument, text, type XmlNode };

package/src/deploy/node-runtime/license.ts

@@ -1,5 +1,5 @@
-import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { readLicenseText } from "../notices/text.js";
 
 const LICENSE_FILENAME = "LICENSE";
 const NODE_MARKER = "Node.js";
@@ -10,13 +10,7 @@ const licenseCandidates = (binary: string): string[] => {
     return [join(dir, LICENSE_FILENAME), join(dir, "..", LICENSE_FILENAME)];
 };
 
-const isNodeLicense = (path: string): boolean => {
-    try {
-        return readFileSync(path, "utf8").includes(NODE_MARKER);
-    } catch {
-        return false;
-    }
-};
+const isNodeLicense = (path: string): boolean => readLicenseText(path)?.includes(NODE_MARKER) === true;
 
 const licenseBesideNode = (binary: string): string | null =>
     licenseCandidates(binary).find((candidate) => isNodeLicense(candidate)) ?? null;

package/src/deploy/notices/packages.ts

@@ -1,4 +1,5 @@
 import { sortStringsBy, warn } from "@gtkx/utils";
+import hostedGitInfo from "hosted-git-info";
 import { existsSync, realpathSync } from "node:fs";
 import { join, resolve } from "node:path";
 import type { RecordedPackage } from "../../internal/build-manifest.js";
@@ -17,10 +18,6 @@ type BundledPackage = {
 };
 
 const MANIFEST_FILENAME = "package.json";
-const GIT_PREFIX = /^git\+/;
-const GIT_SUFFIX = /\.git$/;
-const GIT_SCHEME = /^git:\/\//;
-const GITHUB_SLUG = /^(?:github:)?(?<slug>[\w.-]+\/[\w.-]+)$/;
 
 const realPath = (path: string): string => {
     try {
@@ -47,14 +44,9 @@ const sourceUrl = (manifest: PackageManifest): string | null => {
         return null;
     }
 
-    const url = configured.replace(GIT_PREFIX, "").replace(GIT_SUFFIX, "").replace(GIT_SCHEME, "https://");
-    const slug = GITHUB_SLUG.exec(url)?.groups?.slug;
+    const url = configured.replace(/^git\+/, "").replace(/\.git$/, "").replace(/^git:\/\//, "https://");
 
-    if (slug !== undefined) {
-        return `https://github.com/${slug}`;
-    }
-
-    return url.startsWith("http") ? url : null;
+    return hostedGitInfo.fromUrl(url)?.browse() ?? (url.startsWith("http") ? url : null);
 };
 
 const missingPackage = (entry: RecordedPackage): BundledPackage => ({

package/src/deploy/payload/copy-tree.ts

@@ -1,5 +1,6 @@
+import { isPathInside } from "@gtkx/utils";
 import { chmodSync, copyFileSync, mkdirSync, statSync, writeFileSync } from "node:fs";
-import { dirname, isAbsolute, join, relative } from "node:path";
+import { dirname, join } from "node:path";
 import type { StagedFile } from "../types.js";
 import { listFilesRecursive } from "../../internal/list-files.js";
 
@@ -16,9 +17,7 @@ const modeFor = (rel: string): number => {
 };
 
 const assertInsideRoot = (root: string, rel: string, abs: string): void => {
-    const escape = relative(root, abs);
-
-    if (escape.length === 0 || escape.startsWith("..") || isAbsolute(escape)) {
+    if (!isPathInside(root, abs)) {
         throw new Error(`Cannot stage "${rel}": it resolves outside the staging directory`);
     }
 };

package/src/deploy/payload/stage.ts

@@ -27,7 +27,6 @@ type StagedMetadata = {
 };
 
 const DIST_ICONS_DIR = "icons";
-const LEGACY_PACKAGES_MANIFEST_FILENAME = "gtkx-packages.json";
 const NOTICES_FILENAME = "THIRD-PARTY-NOTICES";
 const NODE_LICENSE_FILENAME = "LICENSE";
 const SHARE_APPLICATIONS = "share/applications";
@@ -50,10 +49,6 @@ const licenseDirFor = (settings: DeploySettings): string => `${SHARE_LICENSES}/$
 const licenseDestination = (settings: DeploySettings): string => `${licenseDirFor(settings)}/LICENSE`;
 const noticesDestination = (settings: DeploySettings): string => `${licenseDirFor(settings)}/${NOTICES_FILENAME}`;
 const isIconAsset = (rel: string): boolean => rel === DIST_ICONS_DIR || rel.startsWith(`${DIST_ICONS_DIR}/`);
-
-const isBuildMetadata = (rel: string): boolean =>
-    rel === BUILD_MANIFEST_FILENAME || rel === LEGACY_PACKAGES_MANIFEST_FILENAME;
-
 const isLocaleAsset = (rel: string): boolean => rel === LOCALE_DIRNAME || rel.startsWith(`${LOCALE_DIRNAME}/`);
 
 const nodeLicenseDestination = (settings: DeploySettings): string =>
@@ -67,7 +62,8 @@ const stageRuntimeFiles = (settings: DeploySettings, root: string): StagedFile[]
     }
 
     return listFilesRecursive(dist)
-        .filter((file) => !isIconAsset(file.rel) && !isBuildMetadata(file.rel) && !isLocaleAsset(file.rel))
+        .filter((file) =>
+            !isIconAsset(file.rel) && file.rel !== BUILD_MANIFEST_FILENAME && !isLocaleAsset(file.rel))
         .map((file) => copyInto(root, join(libDirFor(settings), file.rel), file.absPath));
 };