@sparkelf/dsh-plus 0.2.4-alpha.48 → 0.2.6-alpha.49

package/lib/types/profile.js

@@ -0,0 +1,670 @@
+/**
+ * Runtime paths and profile composition for a standalone Plus installation.
+ *
+ * A standalone consumer installs the distribution from the registry and owns its
+ * profile, so this module answers the two questions every command shares: where the
+ * DSH home and profile live, and what the profile manifest must contain. The bundle
+ * order comes from the installed distribution rather than from a copy here, because
+ * the launcher mounts exactly the bundles the profile names and nothing expands a
+ * bundle's own list.
+ */
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { homedir } from 'node:os';
+import { dirname, join, posix, resolve, win32 } from 'node:path';
+import { parseDocument } from 'yaml';
+import { projectEdition, readDistributionFacts } from "./manifest.js";
+import { readPatchSet } from "./patch-set.js";
+/** Profile name the launcher materializes when no edition is selected. */
+export const DEFAULT_PROFILE = 'plus';
+function requireRecord(value, label) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        throw new Error(label + ' must be an object');
+    return value;
+}
+/**
+ * Resolve the file that was actually invoked from the path the shell was handed.
+ *
+ * A global npm install links `<prefix>/bin/dsh-plus` to the package entry. Resolving
+ * `@sparkelf/dsh-plus` from that link starts at the bin directory, which has no
+ * `node_modules`, so every globally installed command reported the distribution as
+ * missing. The real path is the package file, and the package resolves its own name.
+ *
+ * @param invoked - `process.argv[1]`, or undefined when node ran without a script.
+ * @param fallback - this module's own file, used when there is no script path.
+ * @returns an absolute path that exists, or the input when it cannot be resolved.
+ */
+export function resolveInvocationAnchor(invoked, fallback) {
+    if (invoked === undefined || invoked === '')
+        return realpathSync(fallback);
+    try {
+        return realpathSync(invoked);
+    }
+    catch {
+        // A path the filesystem no longer knows cannot be resolved; the caller's error message is
+        // more useful with what it was given than with a second failure here.
+        return resolve(invoked);
+    }
+}
+/** Resolve the DSH home, honouring the environment override the launcher itself reads. */
+export function resolveHome(env = process.env) {
+    const configured = env.DSH_HOME;
+    return configured === undefined || configured === '' ? join(homedir(), '.dsh') : resolve(configured);
+}
+/**
+ * Whether one absolute path is the other or sits beneath it.
+ *
+ * A path outside the parent has a relative form starting with `..`, which every
+ * platform answers the same way. Comparing the text against a literal separator is
+ * not: Windows separates with a backslash, so a nested path never matched its own
+ * ancestor and every Windows installation reported the distribution as sitting
+ * outside its own tree.
+ *
+ * @param candidate - absolute path to test.
+ * @param parent - absolute path that may contain it.
+ * @param platform - separating convention, injectable so the Windows answer is
+ * testable where the suite runs on a POSIX host.
+ * @returns true when the candidate is the parent or inside it.
+ */
+export function isWithin(candidate, parent, platform = process.platform) {
+    if (candidate === parent)
+        return true;
+    const path = platform === 'win32' ? win32 : posix;
+    const inside = path.relative(parent, candidate);
+    return inside !== '' && !inside.startsWith('..') && !inside.startsWith(path.sep + '..');
+}
+/**
+ * Resolve the installed distribution directory from one requiring anchor.
+ *
+ * The anchor must be a path inside the consumer's own tree. Resolving from this
+ * module instead would find the distribution the module itself was loaded from,
+ * which is the repository during development and the consumer's install otherwise.
+ *
+ * @param anchor - `package.json` path or directory in the consumer tree.
+ * @returns absolute path to the installed distribution.
+ */
+export function resolveDistributionDirectory(anchor) {
+    let resolved;
+    try {
+        resolved = dirname(createRequire(anchor).resolve('@sparkelf/dsh-plus/package.json'));
+    }
+    catch {
+        throw new Error('@sparkelf/dsh-plus is not installed in ' + dirname(anchor) + '; run this command from the directory that installed it');
+    }
+    // A resolution that leaves the consumer tree means the module answered from its own
+    // installation, which reports health for a distribution the consumer never installed.
+    // The comparison walks up from the anchor because the resolved package sits under the
+    // anchor's \`node_modules\`, not beside it: requiring \`<root>/package.json\` legitimately
+    // reports \`<root>/node_modules/@sparkelf/dsh-plus\`.
+    let current = resolve(dirname(anchor));
+    for (;;) {
+        if (isWithin(resolved, current))
+            return resolved;
+        const parent = dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    throw new Error('@sparkelf/dsh-plus resolved outside ' + resolve(dirname(anchor)) + ' (found ' + resolved + '); run this command from the directory that installed it');
+}
+/** The reviewed bundle order and pins the installed distribution declares, for one variant. */
+export function readDistributionProfile(distributionDirectory, editionId, extraExcludes = []) {
+    const facts = readDistributionFacts(distributionDirectory);
+    const projection = projectEdition(facts, editionId, extraExcludes);
+    return {
+        name: facts.name,
+        version: facts.version,
+        dshRange: '>=' + facts.runtimeVersion,
+        runtimeVersion: facts.runtimeVersion,
+        bundles: projection.bundles,
+        dependencies: projection.dependencies,
+        allowBuilds: projection.allowBuilds,
+        overrides: projection.overrides,
+        omittedPackages: projection.omittedPackages,
+        editions: facts.editions,
+    };
+}
+/**
+ * Give the profile its own installed tree, built from the distribution's declarations.
+ *
+ * The launcher resolves a bundle from the profile directory, so the profile needs its
+ * own `node_modules`. Pointing it at the consumer's tree was cheaper, but it made the
+ * profile inherit whatever npm had already installed — including the official packages
+ * the distribution's `overrides` exist to replace. npm applies `overrides` only from a
+ * project's own root, so a profile without its own tree cannot receive them at all, and
+ * a patch delivered that way silently never arrives.
+ *
+ * Installing here makes the profile that root: pnpm reads `overrides` from the
+ * profile's own `pnpm-workspace.yaml`, which `writeProfileOverrides` writes before this
+ * runs. The install is skipped once the tree exists so a start does not pay for it
+ * twice; `dsh-plus apply` remains the command that reinstalls after a change.
+ *
+ * @param paths - resolved standalone paths.
+ */
+export function installProfilePackages(paths, omitted = new Set(), runtimeVersion, registry) {
+    // The profile owns its dependency tree: it declares the launcher and every plugin, so it can
+    // install without a consumer tree beside it. A globally installed distribution has none --
+    // its only node_modules is the one npm laid out around the command itself.
+    const profileModules = join(paths.profileDirectory, 'node_modules');
+    if (existsSync(profileModules)) {
+        // A profile installed before the distribution declared overrides still needs the
+        // packages it reaches from the consumer tree, which npm nested rather than hoisted.
+        linkNestedBundles(paths, profileModules);
+        return;
+    }
+    installWithRegistryFallback(paths.profileDirectory);
+    // A range admits the next prerelease, so the official family lands one generation ahead of
+    // the runtime the republished builds were cut against. Realign, then finish the tree.
+    if (runtimeVersion !== undefined && registry !== undefined) {
+        alignOfficialVersions(paths.profileDirectory, runtimeVersion, registry);
+    }
+    alignReplacedPackageNames(profileModules, omitted);
+    linkNestedBundles(paths, profileModules);
+    assertProfileBundles(paths.profileDirectory);
+}
+/** Package names a package declares as peers on the official runtime family. */
+function officialPeers(profileDirectory) {
+    const peers = new Set();
+    const manifests = [];
+    for (const scope of [join(profileDirectory, 'node_modules'), join(profileDirectory, 'node_modules', '@deepseek-ai')]) {
+        if (!existsSync(scope))
+            continue;
+        for (const entry of readdirSync(scope)) {
+            if (entry.startsWith('.'))
+                continue;
+            if (entry.startsWith('@') && entry !== '@deepseek-ai')
+                continue;
+            if (entry === '@deepseek-ai') {
+                for (const scoped of readdirSync(scope))
+                    manifests.push(join(scope, scoped, 'package.json'));
+                continue;
+            }
+            manifests.push(join(scope, entry, 'package.json'));
+        }
+    }
+    for (const manifestPath of manifests) {
+        if (!existsSync(manifestPath))
+            continue;
+        try {
+            const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+            for (const peer of Object.keys(manifest.peerDependencies ?? {})) {
+                if (peer.startsWith('@deepseek-ai/dsh') && peer !== '@deepseek-ai/dsh')
+                    peers.add(peer);
+            }
+        }
+        catch {
+            // A package whose manifest cannot be read declares no peer this step can act on.
+        }
+    }
+    return peers;
+}
+/**
+ * Which of the given package versions a registry serves.
+ *
+ * The probe runs in one Node child: one process per name is slow, and the caller needs the
+ * answer before the second install.
+ *
+ * @param names - package names to check.
+ * @param version - exact version each must serve.
+ * @param registry - registry base URL.
+ * @returns the names the registry serves at that version.
+ */
+function servedVersions(names, version, registry) {
+    if (names.length === 0)
+        return new Set();
+    const script = `
+    const [names, version, registry] = JSON.parse(process.argv[1])
+    const base = registry.replace(/\\/$/, '')
+    const queue = [...names]
+    const served = []
+    await Promise.all(Array.from({ length: 10 }, async () => {
+      while (queue.length > 0) {
+        const name = queue.shift()
+        try {
+          const response = await fetch(base + '/' + name.replace('/', '%2f') + '/' + version)
+          if (response.ok) served.push(name)
+        } catch {}
+      }
+    }))
+    process.stdout.write(served.join('\\n'))
+  `;
+    const result = spawnSync(process.execPath, ['--input-type=module', '-e', script, JSON.stringify([names, version, registry])], { encoding: 'utf8' });
+    if (result.status !== 0)
+        return new Set();
+    return new Set(result.stdout.split('\n').map(entry => entry.trim()).filter(entry => entry !== ''));
+}
+/**
+ * Move the shared official services onto the runtime's exact version.
+ *
+ * The republished builds were cut against one runtime, and DSH disables a row when the exact
+ * peers a plugin declares disagree with the process it shares. Plugins declare those services as
+ * peers, so the names worth pinning are the peers actually installed -- read from the tree and
+ * checked against the registry. The rest of the official family keeps its resolved versions:
+ * pinning everything traded one mismatch for a tree with holes.
+ *
+ * @param profileDirectory - profile whose tree was just installed.
+ * @param runtimeVersion - exact runtime the profile boots.
+ * @param registry - registry the profile installs from.
+ * @returns how many services were realigned.
+ */
+export function alignOfficialVersions(profileDirectory, runtimeVersion, registry) {
+    const wanted = [...officialPeers(profileDirectory)];
+    const served = servedVersions(wanted, runtimeVersion, registry);
+    if (served.size === 0)
+        return 0;
+    const workspacePath = join(profileDirectory, 'pnpm-workspace.yaml');
+    const document = parseDocument(readFileSync(workspacePath, 'utf8'));
+    let changed = 0;
+    for (const name of served) {
+        if (document.getIn(['overrides', name]) === runtimeVersion)
+            continue;
+        document.setIn(['overrides', name], runtimeVersion);
+        changed += 1;
+    }
+    if (changed === 0)
+        return 0;
+    writeFileSync(workspacePath, String(document));
+    rmSync(join(profileDirectory, 'pnpm-lock.yaml'), { force: true });
+    installWithRegistryFallback(profileDirectory);
+    return changed;
+}
+/**
+ * Assert every bundle row the profile declares resolves in its installed tree.
+ *
+ * A row without an installed package mounts nothing and reports nothing: the client module
+ * system simply never registers it, and every earlier step passes. Reading the rows back from
+ * the manifest on disk rather than from the projection is what makes this cover the tree the
+ * launcher actually boots.
+ *
+ * @param profileDirectory - profile whose node_modules was just installed.
+ */
+export function assertProfileBundles(profileDirectory) {
+    const manifest = JSON.parse(readFileSync(join(profileDirectory, 'package.json'), 'utf8'));
+    const missing = [];
+    for (const name of manifest.dsh?.profile?.bundles ?? []) {
+        if (!existsSync(join(profileDirectory, 'node_modules', name, 'package.json')))
+            missing.push(name);
+    }
+    if (missing.length > 0) {
+        throw new Error('the profile mounts bundles it did not install: ' + missing.join(', '));
+    }
+}
+/**
+ * Install the profile from the first registry that answers.
+ *
+ * The install fetches a full dependency closure, and a mainland consumer reaches the
+ * mirror far faster than the origin. Trying the preferred registry and falling back once
+ * keeps a first start quick without failing when the preferred one is unreachable.
+ *
+ * @param paths - resolved standalone paths.
+ */
+function installWithRegistryFallback(profileDirectory) {
+    const registries = registryOrder();
+    for (const [index, registry] of registries.entries()) {
+        const result = spawnSync('pnpm', ['install', '--no-frozen-lockfile', '--registry', registry], {
+            cwd: profileDirectory,
+            stdio: 'inherit',
+            shell: process.platform === 'win32',
+        });
+        if (result.error !== undefined)
+            throw result.error;
+        if (result.status === 0)
+            return;
+        const next = registries[index + 1];
+        if (next === undefined) {
+            throw new Error('pnpm install in the plus profile failed with exit code ' + String(result.status));
+        }
+        console.log('Install from ' + registry + ' failed; trying ' + next + '.');
+    }
+}
+/**
+ * Make each replaced package declare the name of the location it occupies.
+ *
+ * \`overrides\` installs our build at the official path, but the manifest inside still
+ * names our scope. The client module system resolves a loader entry's declared name and
+ * then requires the manifest it finds to declare that same name
+ * (\`client/modules\`: \`name === expectedPackageName\`); a mismatch makes the package own no
+ * browser module at all. The symptom is silent — the packages install, the server starts,
+ * and the panels those packages render simply never appear.
+ *
+ * The rewrite replaces the file rather than writing through it: pnpm hard-links a package
+ * manifest into its content-addressed store, so an in-place write would edit every
+ * profile sharing that store entry.
+ *
+ * @param profileModules - the profile's \`node_modules\` directory.
+ */
+export function alignReplacedPackageNames(profileModules, omitted = new Set()) {
+    if (!existsSync(profileModules))
+        return;
+    // A replaced package is installed at the name its loader row declares, but the manifest inside
+    // still names our scope: the client module system requires the directory's package to declare
+    // the directory name, so the panels it renders would never register. Both scopes are walked
+    // because a row can be an unscoped alias (`dsh-better-sidebar`) onto a scoped build.
+    const align = (expected, manifestPath) => {
+        if (!existsSync(manifestPath))
+            return;
+        const declared = JSON.parse(readFileSync(manifestPath, 'utf8'));
+        if (declared.name === expected || omitted.has(expected))
+            return;
+        const temporary = manifestPath + '.dsh-name';
+        writeFileSync(temporary, JSON.stringify({ ...declared, name: expected }, null, 2) + '\n');
+        renameSync(temporary, manifestPath);
+    };
+    for (const entry of readdirSync(profileModules)) {
+        if (entry.startsWith('.'))
+            continue;
+        if (!entry.startsWith('@')) {
+            // An unscoped row is an npm alias onto a scoped build. The package imports its real
+            // scoped name, so renaming it would break its own imports; exposing the scoped name as
+            // a link is what makes both the row and the package resolve.
+            const manifestPath = join(profileModules, entry, 'package.json');
+            if (!existsSync(manifestPath))
+                continue;
+            const declared = JSON.parse(readFileSync(manifestPath, 'utf8'));
+            if (declared.name === undefined || declared.name === entry)
+                continue;
+            const [scope, name] = declared.name.split('/');
+            if (scope === undefined || name === undefined)
+                continue;
+            mkdirSync(join(profileModules, scope), { recursive: true });
+            const link = join(profileModules, scope, name);
+            if (existsSync(link))
+                continue;
+            try {
+                symlinkSync(join('..', entry), link, 'junction');
+            }
+            catch {
+                // A concurrent install may have created the same link; the existing one is equivalent.
+            }
+            continue;
+        }
+        for (const scoped of readdirSync(join(profileModules, entry))) {
+            align(entry + '/' + scoped, join(profileModules, entry, scoped, 'package.json'));
+        }
+    }
+}
+/** The npm registry the distribution installs from by default. */
+const OFFICIAL_REGISTRY = 'https://registry.npmjs.org';
+/** The mainland mirror, which serves the same packages and answers faster there. */
+const MAINLAND_REGISTRY = 'https://registry.npmmirror.com';
+/**
+ * The registries to try, in order, for this machine.
+ *
+ * A mainland locale reaches the mirror faster than the origin, which is why the Desktop
+ * installer already prefers it there. The same choice belongs to the profile install: it
+ * fetches a full dependency closure, so the delay is the first thing a consumer notices.
+ * `DSH_PLUS_INSTALL_REGISTRY` overrides the choice, and a failure falls back once.
+ *
+ * @returns registries to try in order.
+ */
+export function registryOrder() {
+    const configured = process.env.DSH_PLUS_INSTALL_REGISTRY;
+    if (configured !== undefined && configured !== '')
+        return [configured, MAINLAND_REGISTRY];
+    // Intl reports the system locale on every platform. The POSIX variables are empty on
+    // Windows, so reading them alone classified every Windows console as non-mainland and
+    // reached the origin first — measured in a consumer's log, which showed npmjs failing
+    // before the mirror answered.
+    const locale = [process.env.LANG, process.env.LC_ALL, Intl.DateTimeFormat().resolvedOptions().locale]
+        .filter(value => value !== undefined)
+        .join(' ')
+        .toLowerCase();
+    const mainlandFirst = locale.includes('zh') || locale.includes('cn');
+    return mainlandFirst ? [MAINLAND_REGISTRY, OFFICIAL_REGISTRY] : [OFFICIAL_REGISTRY, MAINLAND_REGISTRY];
+}
+/**
+ * Report whether pnpm can run.
+ *
+ * The profile installs its own tree so its \`overrides\` apply, and only pnpm reads those
+ * from a workspace, so pnpm is a prerequisite the distribution cannot supply. Probing
+ * first turns a cryptic failure from the install into a message naming what is missing.
+ *
+ * @returns \`true\` when pnpm answers with a version.
+ */
+export function pnpmAvailable() {
+    const probe = spawnSync('pnpm', ['--version'], {
+        stdio: 'pipe',
+        shell: process.platform === 'win32',
+        encoding: 'utf8',
+    });
+    return probe.status === 0;
+}
+/**
+ * The commands that install pnpm, in the order worth trying.
+ *
+ * Corepack ships with Node and needs no download, so it comes first; npm is the fallback
+ * for an installation whose Corepack is absent or disabled. Both are the consumer's own
+ * toolchain, which is what lets the first start offer to install rather than only report.
+ *
+ * @returns commands to try in order, stopping at the first that works.
+ */
+export function pnpmInstallCommands() {
+    const registry = registryOrder()[0];
+    if (registry === undefined)
+        return ['corepack enable pnpm', 'npm install -g pnpm'];
+    // Both installers take the registry explicitly. npm does so with a flag; corepack reads
+    // COREPACK_NPM_REGISTRY, which the caller sets. A mainland consumer therefore downloads
+    // the package from the mirror, for the same reason the profile install prefers it.
+    return ['corepack enable pnpm', 'npm install -g pnpm --registry ' + registry];
+}
+/**
+ * The command to show a consumer who declines the automatic install.
+ *
+ * @returns the preferred command, which is the one the offer runs first.
+ */
+export function pnpmInstallCommand() {
+    return pnpmInstallCommands()[0] ?? 'npm install -g pnpm';
+}
+/**
+ * Expose the distribution's nested packages at the top level the profile searches.
+ *
+ * The profile resolves a bundle from one directory, so a package npm nested under the
+ * distribution is invisible there even though the installation carries it. Linking each
+ * one beside the hoisted packages keeps a single installed copy and needs no reinstall.
+ *
+ * @param paths - resolved standalone paths.
+ * @param consumerModules - the consumer's `node_modules` directory.
+ */
+function linkNestedBundles(paths, consumerModules) {
+    const nested = join(paths.distributionDirectory, 'node_modules');
+    if (!existsSync(nested))
+        return;
+    for (const entry of readdirSync(nested)) {
+        if (entry.startsWith('@')) {
+            for (const scoped of readdirSync(join(nested, entry))) {
+                linkBundle(consumerModules, join(entry, scoped), join(nested, entry, scoped));
+            }
+            continue;
+        }
+        linkBundle(consumerModules, entry, join(nested, entry));
+    }
+}
+/** Link one nested bundle into the consumer's top level when it is not already there. */
+function linkBundle(consumerModules, name, source) {
+    const destination = join(consumerModules, name);
+    if (existsSync(destination))
+        return;
+    try {
+        symlinkSync(source, destination, 'junction');
+    }
+    catch {
+        // A concurrent start may have created the same link; the existing one is equivalent.
+    }
+}
+/** Resolve every path a command needs, without creating anything. */
+export function resolvePaths(anchor, env = process.env, editionId) {
+    const home = resolveHome(env);
+    const distributionDirectory = resolveDistributionDirectory(anchor);
+    // The edition is a fact of the distribution: it names the profile and the capabilities the
+    // deployment omits. No edition means the full distribution and its default profile.
+    let profileName = DEFAULT_PROFILE;
+    let omittedPackages = {};
+    if (editionId !== undefined) {
+        const projection = projectEdition(readDistributionFacts(distributionDirectory), editionId);
+        profileName = projection.profileName;
+        omittedPackages = projection.omittedPackages;
+    }
+    return {
+        home,
+        profileName,
+        omittedPackages,
+        profileDirectory: join(home, 'profiles', profileName),
+        distributionDirectory,
+    };
+}
+/**
+ * Write the profile manifest when it is absent, leaving an existing one untouched.
+ *
+ * The distribution's own plugin dependencies are seeded here so the launcher can
+ * resolve every bundle from the profile directory: a bundle the profile cannot
+ * resolve fails activation with a module-resolution error, and no step in the
+ * launcher expands the distribution's bundle list on its own.
+ *
+ * The profile also links the consumer's installed packages, because the launcher
+ * resolves each bundle from the profile directory rather than from the directory
+ * that installed them.
+ *
+ * @param paths - resolved standalone paths.
+ * @param editionId - product edition to materialize.
+ * @param extraExcludes - packages the caller drops on top of the edition's own exclusions.
+ * @param dryRun - write the profile files without installing their dependency tree.
+ * @returns whether this call created the manifest.
+ */
+export function ensureProfile(paths, editionId, extraExcludes = [], dryRun = false) {
+    const manifestPath = join(paths.profileDirectory, 'package.json');
+    const distribution = readDistributionProfile(paths.distributionDirectory, editionId, extraExcludes);
+    if (existsSync(manifestPath)) {
+        // The workspace carries decisions the distribution owns — overrides and the build
+        // script allowlist — and a distribution release changes them. Rewriting on every
+        // start is what lets an upgraded installation receive the new values; a profile
+        // written once keeps whatever its own release decided and can never be corrected.
+        writeProfileOverrides(paths.profileDirectory, distribution.overrides, distribution.allowBuilds, { ...paths.omittedPackages, ...distribution.omittedPackages });
+        if (!dryRun) {
+            installProfilePackages(paths, new Set(Object.keys(distribution.omittedPackages)), distribution.runtimeVersion, registryOrder()[0]);
+        }
+        return false;
+    }
+    mkdirSync(paths.profileDirectory, { recursive: true });
+    const manifest = {
+        name: 'dsh-profile-' + paths.profileName,
+        private: true,
+        type: 'module',
+        dependencies: {
+            '@sparkelf/dsh-plus': distribution.version,
+            // The launcher's own tree supplies every service package the bundles mount. A
+            // profile that lists only the distribution's plugins installs a partial tree and
+            // fails at load with a module the launcher would have carried.
+            '@deepseek-ai/dsh': distribution.dshRange,
+            ...distribution.dependencies,
+        },
+        dsh: {
+            profile: {
+                bundles: distribution.bundles,
+                patchReload: 'live',
+            },
+        },
+    };
+    writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
+    // The overrides must reach the workspace before the install that reads them.
+    writeProfileOverrides(paths.profileDirectory, distribution.overrides, distribution.allowBuilds, { ...paths.omittedPackages, ...distribution.omittedPackages });
+    if (!dryRun) {
+        installProfilePackages(paths, new Set(Object.keys(distribution.omittedPackages)), distribution.runtimeVersion, registryOrder()[0]);
+    }
+    return true;
+}
+/**
+ * Record the distribution's package substitutions in the profile workspace.
+ *
+ * pnpm reads \`overrides\` from \`pnpm-workspace.yaml\` since version 10 and ignores the
+ * same key in \`package.json\`, so a profile that carried it in the manifest would
+ * silently install the official package the override meant to replace.
+ *
+ * @param profileDirectory - the standalone profile directory.
+ * @param overrides - official package name to published replacement spec.
+ */
+function writeProfileOverrides(profileDirectory, overrides, allowBuilds, omittedPackages) {
+    const workspacePath = join(profileDirectory, 'pnpm-workspace.yaml');
+    const document = parseDocument(existsSync(workspacePath) ? readFileSync(workspacePath, 'utf8') : '');
+    const [documentError] = document.errors;
+    if (documentError !== undefined)
+        throw new Error('Plus profile workspace is not valid YAML', { cause: documentError });
+    if (document.get('packages') === undefined)
+        document.set('packages', ['.']);
+    for (const [name, spec] of Object.entries(overrides))
+        document.setIn(['overrides', name], spec);
+    // A capability the deployment omits is substituted rather than deleted, because npm's
+    // override has no removal form. Writing it here keeps the omission in the one place
+    // pnpm reads, so an install never receives the capability the variant excluded.
+    for (const [name, spec] of Object.entries(omittedPackages))
+        document.setIn(['overrides', name], spec);
+    // pnpm refuses an install whose packages want to run build scripts until each is
+    // decided, so the distribution's reviewed decisions travel with the install rather
+    // than waiting for an interactive approval no start can offer.
+    for (const [name, allowed] of Object.entries(allowBuilds))
+        document.setIn(['allowBuilds', name], allowed);
+    // The profile resolves bundles from this directory, so peers the official tree would
+    // supply have to come from what the consumer installed.
+    if (document.get('nodeLinker') === undefined)
+        document.set('nodeLinker', 'hoisted');
+    if (document.get('autoInstallPeers') === undefined)
+        document.set('autoInstallPeers', false);
+    writeFileSync(workspacePath, String(document));
+}
+/** Run git in one directory, returning undefined instead of throwing when asked to. */
+function git(root, args, acceptFailure = false) {
+    const result = spawnSync('git', args, { cwd: root, encoding: 'utf8' });
+    if (result.status === 0)
+        return result.stdout.trim();
+    if (acceptFailure)
+        return undefined;
+    const detail = result.stderr.trim();
+    throw new Error('git ' + args.join(' ') + ' failed' + (detail === '' ? '' : ': ' + detail));
+}
+/**
+ * Apply the reviewed npm-target patches to the profile's installed packages.
+ *
+ * A standalone installation runs no `apply` step: it installs the distribution from
+ * the registry, links the consumer's packages, and starts. The npm patches a
+ * distribution declares therefore need an owner that does not require an official
+ * source checkout — the source half of the apply step needs one, this does not.
+ *
+ * The work is idempotent: a patch whose reverse already applies is left alone, so a
+ * second start neither re-applies nor fails. A reinstall restores the published bytes,
+ * which is why this runs on every start rather than once.
+ *
+ * @param distributionDirectory - the installed `@sparkelf/dsh-plus` directory.
+ * @param profileDirectory - the standalone profile directory.
+ * @returns the labels of the patches that were applied.
+ */
+export function applyProfileNpmPatches(distributionDirectory, profileDirectory) {
+    const manifest = requireRecord(JSON.parse(readFileSync(join(distributionDirectory, 'package.json'), 'utf8')), 'Plus distribution manifest');
+    const patchSet = readPatchSet(distributionDirectory, manifest);
+    const applied = [];
+    for (const entry of [...patchSet.entries, ...patchSet.thirdPartyPatches]) {
+        if (entry.target.kind !== 'npm')
+            continue;
+        const targetName = entry.target.name;
+        const patched = resolveInstalledPackage(profileDirectory, targetName);
+        const file = resolve(distributionDirectory, entry.file);
+        if (git(patched.directory, ['apply', '--reverse', '--check', file], true) !== undefined)
+            continue;
+        git(patched.directory, ['apply', file]);
+        applied.push(entry.id + ' -> ' + targetName);
+    }
+    return applied;
+}
+/** Resolve one installed package's manifest from a requiring directory. */
+function resolveInstalledPackage(from, packageName) {
+    const requireFrom = createRequire(join(from, 'package.json'));
+    let manifestPath;
+    try {
+        manifestPath = requireFrom.resolve(packageName + '/package.json');
+    }
+    catch {
+        throw new Error(packageName + ' is not installed under ' + from);
+    }
+    const manifest = requireRecord(JSON.parse(readFileSync(manifestPath, 'utf8')), packageName + ' manifest');
+    return { name: packageName, version: String(manifest.version), directory: dirname(manifestPath), manifest };
+}
+//# sourceMappingURL=profile.js.map