@mpgd/cli 0.34.0 → 0.35.0

package/dist/index.js

@@ -17,6 +17,7 @@ import { cloudflarePagesDeploymentProfiles, hostedPwaDeploymentHosts, verifyHost
 import { createMicrosoftStorePackageAcceptanceRuntime, runMicrosoftStorePackageAcceptance, } from './microsoft-store-package-acceptance.js';
 import { runMicrosoftStorePackageGeneration } from './microsoft-store-package-generation.js';
 import { defaultMpgdKitPath, initializeMicrosoftStoreStarter, listMicrosoftStoreInitializerTemplateFiles, prepareBaseGameTemplateFile, resolveMicrosoftStoreAdapterDependencyVersion, } from './microsoft-store-starter.js';
+import { applyKitUpgrade, planKitUpgrade } from './kit-upgrade.js';
 import { runMicrosoftStoreSubmissionPreflight } from './microsoft-store-submission.js';
 import { defaultOfflinePlaytestArtifactDir, defaultOfflinePlaytestMaximumBytes, defaultOfflinePlaytestOutputDir, runOfflinePlaytestPackaging, } from './offline-playtest.js';
 import { targetConfigExtensionsFileEnv } from './target-config-env.js';
@@ -135,7 +136,7 @@ export async function runMpgdCli(args) {
         // partial document. Every other command keeps the default rendering.
         renderHeader: async (ctx) => {
             const values = ctx.values;
-            if (ctx.name === 'verify-delivery' && values.json === true) {
+            if ((ctx.name === 'verify-delivery' || ctx.name === 'upgrade') && values.json === true) {
                 return '';
             }
             const title = ctx.env.description || ctx.env.name || '';
@@ -146,7 +147,7 @@ export async function runMpgdCli(args) {
         renderValidationErrors: async (ctx, error) => {
             const messages = error.errors.map((entry) => String(entry.message)).join('\n');
             const values = ctx.values;
-            if (ctx.name === 'verify-delivery' && values.json === true) {
+            if ((ctx.name === 'verify-delivery' || ctx.name === 'upgrade') && values.json === true) {
                 process.stderr.write(`${messages}\n`);
                 return '';
             }
@@ -2042,6 +2043,76 @@ const kitCommand = defineI18n({
         ko: '현재 mpgd-kit 체크아웃을 점검합니다.',
     }),
     subCommands: {
+        upgrade: defineI18n({
+            name: 'upgrade',
+            description: 'Plan or apply the latest published Kit package versions for a game.',
+            resource: commandResource({
+                base: {
+                    en: 'Plan or apply the latest published Kit package versions for a game.',
+                    ko: '게임에 배포된 최신 Kit 패키지 버전 적용을 계획하거나 실행합니다.',
+                },
+                args: {
+                    game: {
+                        en: 'Game directory containing package.json and optional mpgd.targets.json.',
+                        ko: 'package.json과 선택적 mpgd.targets.json이 있는 게임 디렉터리.',
+                    },
+                    'targets-file': {
+                        en: 'Optional game-owned target configuration file.',
+                        ko: '선택적 게임 소유 타깃 구성 파일.',
+                    },
+                    apply: {
+                        en: 'Write the planned manifests and pnpm lockfiles.',
+                        ko: '계획된 의존성 선언과 pnpm 락파일을 갱신합니다.',
+                    },
+                    json: {
+                        en: 'Write one machine-readable JSON document to stdout.',
+                        ko: '표준 출력에 기계 판독용 JSON 문서 하나를 출력합니다.',
+                    },
+                },
+            }),
+            args: {
+                game: { type: 'string', required: false, default: '.', description: 'Game directory.' },
+                'targets-file': { type: 'string', required: false, description: 'Target config file.' },
+                apply: { type: 'boolean', required: false, description: 'Apply the upgrade plan.' },
+                json: { type: 'boolean', required: false, description: 'Print JSON.' },
+            },
+            run: async (ctx) => {
+                const game = readOptionalString(ctx.values.game) ?? '.';
+                const plan = await planKitUpgrade(game, undefined, readOptionalString(ctx.values['targets-file']));
+                const result = ctx.values.apply === true && plan.blockers.length === 0
+                    ? applyKitUpgrade(plan)
+                    : undefined;
+                if (ctx.values.json === true) {
+                    process.stdout.write(JSON.stringify({ plan, result: result ?? null }, null, 2) + '\n');
+                }
+                else {
+                    console.info('Kit upgrade plan for ' + plan.gameRoot);
+                    for (const update of plan.updates) {
+                        console.info('  ' + path.relative(plan.gameRoot, update.manifest)
+                            + ': ' + update.packageName + ' ' + update.current + ' -> ' + update.next);
+                    }
+                    if (plan.updates.length === 0) {
+                        console.info('  Already current for published npm latest tags.');
+                    }
+                    for (const note of plan.notes) {
+                        console.info('Note: ' + note);
+                    }
+                    for (const blocker of plan.blockers) {
+                        console.error('Blocked: ' + blocker);
+                    }
+                    if (result !== undefined) {
+                        console.info('Updated ' + result.manifests.length + ' manifest(s) and '
+                            + result.lockfiles.length + ' lockfile(s). Run target checks before release.');
+                    }
+                    else if (plan.updates.length > 0 && plan.blockers.length === 0) {
+                        console.info('Run again with --apply to update manifests and pnpm lockfiles.');
+                    }
+                }
+                if (plan.blockers.length > 0) {
+                    process.exitCode = 1;
+                }
+            },
+        }),
         doctor: defineI18n({
             name: 'doctor',
             description: 'Print CLI, kit, template, and target-wrapper status.',
@@ -2060,7 +2131,7 @@ const kitCommand = defineI18n({
         }),
     },
     run: () => {
-        console.info('Use "mpgd kit doctor".');
+        console.info('Use "mpgd kit doctor" or "mpgd kit upgrade --game <directory> [--apply]".');
     },
 });
 function commandResource(description, args = {}) {

package/dist/kit-upgrade.d.ts

@@ -0,0 +1,39 @@
+declare const dependencySections: readonly ['dependencies', 'devDependencies', 'optionalDependencies'];
+type DependencySection = (typeof dependencySections)[number];
+export interface PublishedKitPackage {
+  readonly version: string;
+  readonly peerDependencies?: Readonly<Record<string, string>>;
+  readonly optionalPeerDependencies?: readonly string[];
+}
+export type LatestKitPackageLookup = (name: string, gameRoot: string) => Promise<PublishedKitPackage>;
+export interface KitUpgradeUpdate {
+  readonly manifest: string;
+  readonly section: DependencySection;
+  readonly packageName: string;
+  readonly current: string;
+  readonly next: string;
+  readonly latestVersion: string;
+}
+export interface KitUpgradePlan {
+  readonly gameRoot: string;
+  readonly updates: readonly KitUpgradeUpdate[];
+  readonly blockers: readonly string[];
+  readonly notes: readonly string[];
+  readonly manifestDigests: Readonly<Record<string, string>>;
+  readonly targetConfigDigest: {
+    readonly file: string;
+    readonly sha256: string | null;
+  };
+  readonly lockfileDigests: Readonly<Record<string, string>>;
+  readonly workspaceRoots: readonly string[];
+}
+export interface KitUpgradeApplyResult {
+  readonly manifests: readonly string[];
+  readonly lockfiles: readonly string[];
+}
+export type KitUpgradeLockfileRunner = (workspaceRoot: string) => void;
+export declare function planKitUpgrade(gameDirectory: string, lookup?: LatestKitPackageLookup, targetsFileName?: string): Promise<KitUpgradePlan>;
+export declare function applyKitUpgrade(plan: KitUpgradePlan, runLockfileUpdate?: KitUpgradeLockfileRunner): KitUpgradeApplyResult;
+export declare function lookupPublishedKitPackage(packageName: string, gameRoot: string): Promise<PublishedKitPackage>;
+export declare function parsePublishedKitPackageResponse(source: string, packageName: string): PublishedKitPackage;
+export {};

package/dist/kit-upgrade.js

@@ -0,0 +1,486 @@
+import { execFile as execFileCallback, spawnSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { existsSync, lstatSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { compare, intersects, minVersion, satisfies, valid, validRange } from 'semver';
+const execFile = promisify(execFileCallback);
+const dependencySections = ['dependencies', 'devDependencies', 'optionalDependencies'];
+export async function planKitUpgrade(gameDirectory, lookup = lookupPublishedKitPackage, targetsFileName) {
+    const gameRoot = realpathSync(path.resolve(gameDirectory));
+    const gameManifest = path.join(gameRoot, 'package.json');
+    if (!existsSync(gameManifest)) {
+        throw new Error('Game package.json is missing: ' + gameManifest);
+    }
+    if (lstatSync(gameManifest).isSymbolicLink() || !inside(gameRoot, realpathSync(gameManifest))) {
+        throw new Error('Refusing to update a linked game package.json: ' + gameManifest);
+    }
+    const notes = [];
+    const blockers = [];
+    const { manifests, targetConfigDigest } = discoverGameManifests(gameRoot, notes, blockers, targetsFileName);
+    const manifestDigests = {};
+    const requested = new Set();
+    const parsedManifests = new Map();
+    for (const manifest of manifests) {
+        const source = readFileSync(manifest, 'utf8');
+        manifestDigests[manifest] = digest(source);
+        const parsed = parseJsonObject(source, manifest);
+        parsedManifests.set(manifest, parsed);
+        for (const section of dependencySections) {
+            for (const [name, value] of Object.entries(asObject(parsed[section]))) {
+                if (!name.startsWith('@mpgd/') || typeof value !== 'string') {
+                    continue;
+                }
+                if (!isKitPackageName(name)) {
+                    blockers.push('Invalid Kit package name in ' + manifest + ': ' + name);
+                    continue;
+                }
+                if (parseVersionSpecifier(value) === undefined) {
+                    if (validRange(value) !== null) {
+                        blockers.push('Unsupported Kit version range for ' + name + ' in ' + manifest
+                            + ': ' + value + '. Pin an exact version, ^version, or ~version before upgrading.');
+                    }
+                    else {
+                        notes.push('Skipped non-SemVer dependency ' + name + ' in ' + manifest + ': ' + value);
+                    }
+                }
+                else {
+                    requested.add(name);
+                }
+            }
+        }
+    }
+    const packages = new Map();
+    const names = [...requested].sort();
+    for (let index = 0; index < names.length; index += 4) {
+        await Promise.all(names.slice(index, index + 4).map(async (name) => {
+            try {
+                const published = await lookup(name, gameRoot);
+                if (valid(published.version) === null) {
+                    throw new Error('registry returned a non-SemVer latest version');
+                }
+                packages.set(name, published);
+            }
+            catch (error) {
+                blockers.push('Cannot resolve npm latest for ' + name + ': ' + formatError(error));
+            }
+        }));
+    }
+    const updates = [];
+    const peerSubjects = [];
+    for (const manifest of manifests) {
+        const parsed = parsedManifests.get(manifest);
+        if (parsed === undefined) {
+            continue;
+        }
+        for (const section of dependencySections) {
+            for (const [name, value] of Object.entries(asObject(parsed[section]))) {
+                if (!name.startsWith('@mpgd/') || typeof value !== 'string') {
+                    continue;
+                }
+                const current = parseVersionSpecifier(value);
+                const published = packages.get(name);
+                if (current === undefined || published === undefined) {
+                    continue;
+                }
+                if (compare(published.version, current.version) < 0) {
+                    notes.push('Kept ' + name + ' in ' + manifest + ': current version is newer than npm latest.');
+                }
+                else {
+                    const next = compare(published.version, current.version) > 0
+                        ? current.prefix + published.version
+                        : value;
+                    const subject = {
+                        manifest,
+                        section,
+                        packageName: name,
+                        current: value,
+                        next,
+                        latestVersion: published.version,
+                    };
+                    peerSubjects.push(subject);
+                    if (next !== value) {
+                        updates.push(subject);
+                    }
+                }
+            }
+        }
+    }
+    validatePeers(peerSubjects, updates, packages, parsedManifests, gameManifest, blockers, notes);
+    const { lockfileDigests, workspaceRoots } = discoverLockfiles(gameRoot, manifests, blockers, notes);
+    const cliUpdate = updates.find((update) => update.packageName === '@mpgd/cli');
+    if (process.env.MPGD_KIT_PATH !== undefined && cliUpdate !== undefined) {
+        const kitPackageFile = path.resolve(process.env.MPGD_KIT_PATH, 'packages/cli/package.json');
+        if (existsSync(kitPackageFile)) {
+            const kitPackage = parseJsonObject(readFileSync(kitPackageFile, 'utf8'), kitPackageFile);
+            if (kitPackage.version !== cliUpdate.latestVersion) {
+                notes.push('MPGD_KIT_PATH still has CLI ' + String(kitPackage.version)
+                    + '; select the published ' + cliUpdate.latestVersion + ' Kit tag before a release.');
+            }
+        }
+    }
+    return {
+        gameRoot,
+        updates,
+        blockers,
+        notes: [...new Set(notes)],
+        manifestDigests,
+        targetConfigDigest,
+        lockfileDigests,
+        workspaceRoots,
+    };
+}
+export function applyKitUpgrade(plan, runLockfileUpdate = updatePnpmLockfile) {
+    if (plan.blockers.length > 0) {
+        throw new Error('Kit upgrade is blocked:\n' + plan.blockers.join('\n'));
+    }
+    if (plan.updates.length === 0) {
+        return { manifests: [], lockfiles: [] };
+    }
+    const { file: targetsFile, sha256: targetsDigest } = plan.targetConfigDigest;
+    if (targetsDigest === null) {
+        if (existsSync(targetsFile)) {
+            throw new Error('File changed after upgrade planning: ' + targetsFile);
+        }
+    }
+    else if (!existsSync(targetsFile) || digest(readFileSync(targetsFile, 'utf8')) !== targetsDigest) {
+        throw new Error('File changed after upgrade planning: ' + targetsFile);
+    }
+    const snapshots = new Map();
+    for (const [file, expected] of Object.entries({
+        ...plan.manifestDigests,
+        ...plan.lockfileDigests,
+    })) {
+        const current = readFileSync(file, 'utf8');
+        if (digest(current) !== expected) {
+            throw new Error('File changed after upgrade planning: ' + file);
+        }
+        snapshots.set(file, current);
+    }
+    const changedManifests = [...new Set(plan.updates.map((update) => update.manifest))];
+    try {
+        for (const manifest of changedManifests) {
+            const source = snapshots.get(manifest);
+            if (source === undefined) {
+                throw new Error('Missing manifest snapshot: ' + manifest);
+            }
+            const parsed = parseJsonObject(source, manifest);
+            for (const update of plan.updates.filter((item) => item.manifest === manifest)) {
+                const section = asObject(parsed[update.section]);
+                if (section[update.packageName] !== update.current) {
+                    throw new Error('Dependency changed after planning: ' + update.packageName);
+                }
+                section[update.packageName] = update.next;
+                parsed[update.section] = section;
+            }
+            writeFileSync(manifest, stringifyLike(source, parsed));
+        }
+        for (const root of plan.workspaceRoots) {
+            runLockfileUpdate(root);
+        }
+    }
+    catch (error) {
+        const restoreFailures = [];
+        for (const [file, original] of snapshots) {
+            try {
+                writeFileSync(file, original);
+            }
+            catch (restoreError) {
+                restoreFailures.push(file + ': ' + formatError(restoreError));
+            }
+        }
+        const restoration = restoreFailures.length === 0
+            ? 'Original manifests and lockfiles were rolled back.'
+            : 'Rollback incomplete:\n' + restoreFailures.join('\n');
+        throw new Error('Kit upgrade failed during lockfile update: ' + formatError(error)
+            + '\n' + restoration);
+    }
+    return { manifests: changedManifests, lockfiles: Object.keys(plan.lockfileDigests) };
+}
+export async function lookupPublishedKitPackage(packageName, gameRoot) {
+    if (!isKitPackageName(packageName)) {
+        throw new Error('Invalid Kit package name: ' + packageName);
+    }
+    const executable = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+    const { stdout } = await execFile(executable, [
+        'view',
+        packageName + '@latest',
+        'version',
+        'peerDependencies',
+        'peerDependenciesMeta',
+        '--json',
+    ], {
+        cwd: gameRoot,
+        encoding: 'utf8',
+        maxBuffer: 512 * 1024,
+        timeout: 20_000,
+        shell: process.platform === 'win32',
+    });
+    return parsePublishedKitPackageResponse(String(stdout), packageName);
+}
+export function parsePublishedKitPackageResponse(source, packageName) {
+    let parsed;
+    try {
+        parsed = JSON.parse(source);
+    }
+    catch (error) {
+        throw new Error('Invalid npm view JSON for ' + packageName + ': ' + formatError(error));
+    }
+    const response = typeof parsed === 'string' ? { version: parsed } : asObject(parsed);
+    if (typeof response.version !== 'string') {
+        throw new Error('Registry did not return a latest version for ' + packageName);
+    }
+    const peers = asObject(response.peerDependencies);
+    const peerMetadata = asObject(response.peerDependenciesMeta);
+    const declaredPeers = Object.entries(peers).filter((entry) => typeof entry[1] === 'string');
+    const optionalPeerDependencies = declaredPeers
+        .filter(([name]) => asObject(peerMetadata[name]).optional === true)
+        .map(([name]) => name);
+    return {
+        version: response.version,
+        peerDependencies: Object.fromEntries(declaredPeers),
+        ...(optionalPeerDependencies.length > 0 ? { optionalPeerDependencies } : {}),
+    };
+}
+function discoverGameManifests(gameRoot, notes, blockers, targetsFileName) {
+    const manifests = new Set([path.join(gameRoot, 'package.json')]);
+    const targetsFile = path.resolve(gameRoot, targetsFileName ?? 'mpgd.targets.json');
+    if (!inside(gameRoot, targetsFile)) {
+        throw new Error('Targets file must be inside the game directory: ' + targetsFile);
+    }
+    if (!existsSync(targetsFile)) {
+        if (targetsFileName === undefined) {
+            notes.push('No mpgd.targets.json found; only the game manifest will be updated.');
+        }
+        else {
+            blockers.push('Requested targets file is missing: ' + targetsFile);
+        }
+        return { manifests: [...manifests], targetConfigDigest: { file: targetsFile, sha256: null } };
+    }
+    if (lstatSync(targetsFile).isSymbolicLink() || !inside(gameRoot, realpathSync(targetsFile))) {
+        throw new Error('Refusing to read a linked targets file: ' + targetsFile);
+    }
+    const targetsSource = readFileSync(targetsFile, 'utf8');
+    const config = parseJsonObject(targetsSource, targetsFile);
+    const targetsDirectory = path.dirname(targetsFile);
+    for (const value of Object.values(asObject(config.targets))) {
+        const target = asObject(value);
+        for (const key of ['wrapperApp', 'shellApp']) {
+            const location = target[key];
+            if (typeof location !== 'string') {
+                continue;
+            }
+            if (location.includes('${MPGD_KIT_PATH}')) {
+                notes.push('Skipped external target ' + key + ': ' + location);
+                continue;
+            }
+            const resolvedLocation = location
+                .replaceAll('${MPGD_GAME_ROOT}', targetsDirectory)
+                .replaceAll('${MPGD_GAME_APP_ROOT}', targetsDirectory);
+            if (resolvedLocation.includes('$' + '{')) {
+                notes.push('Skipped target with unresolved path token: ' + location);
+                continue;
+            }
+            const directory = path.resolve(targetsDirectory, resolvedLocation);
+            if (!inside(gameRoot, directory)) {
+                notes.push('Skipped target outside the game directory: ' + location);
+                continue;
+            }
+            const manifest = path.join(directory, 'package.json');
+            if (!existsSync(manifest)) {
+                notes.push('Skipped target without package.json: ' + location);
+                continue;
+            }
+            if (lstatSync(manifest).isSymbolicLink() || !inside(gameRoot, realpathSync(manifest))) {
+                notes.push('Skipped linked target manifest: ' + location);
+                continue;
+            }
+            manifests.add(manifest);
+        }
+    }
+    return {
+        manifests: [...manifests].sort(),
+        targetConfigDigest: { file: targetsFile, sha256: digest(targetsSource) },
+    };
+}
+function discoverLockfiles(gameRoot, manifests, blockers, notes) {
+    const roots = new Set();
+    let boundary = gameRoot;
+    for (;;) {
+        if (existsSync(path.join(boundary, '.git'))) {
+            break;
+        }
+        const parent = path.dirname(boundary);
+        if (parent === boundary) {
+            boundary = gameRoot;
+            notes.push('No git boundary found; lockfile discovery is limited to the game directory.');
+            break;
+        }
+        boundary = parent;
+    }
+    for (const manifest of manifests) {
+        let directory = path.dirname(manifest);
+        while (inside(boundary, directory)) {
+            const lockfile = path.join(directory, 'pnpm-lock.yaml');
+            if (existsSync(lockfile)) {
+                if (lstatSync(lockfile).isSymbolicLink()) {
+                    blockers.push('Refusing to rewrite a linked pnpm lockfile: ' + lockfile);
+                }
+                else {
+                    roots.add(directory);
+                }
+            }
+            if (directory === boundary) {
+                break;
+            }
+            directory = path.dirname(directory);
+        }
+    }
+    if (roots.size === 0) {
+        blockers.push('No pnpm-lock.yaml found for the game and its target manifests.');
+    }
+    const workspaceRoots = [...roots].sort((left, right) => left.length - right.length);
+    return {
+        workspaceRoots,
+        lockfileDigests: Object.fromEntries(workspaceRoots.map((root) => {
+            const file = path.join(root, 'pnpm-lock.yaml');
+            return [file, digest(readFileSync(file, 'utf8'))];
+        })),
+    };
+}
+function validatePeers(subjects, updates, packages, manifests, gameManifest, blockers, notes) {
+    const replacements = new Map(updates.map((update) => [update.manifest + '\0' + update.packageName, update.next]));
+    for (const subject of subjects) {
+        const published = packages.get(subject.packageName);
+        const peers = published?.peerDependencies ?? {};
+        const optionalPeers = new Set(published?.optionalPeerDependencies ?? []);
+        for (const [peerName, range] of Object.entries(peers)) {
+            if (validRange(range) === null) {
+                blockers.push('Invalid published peer range for ' + subject.packageName + ': '
+                    + peerName + ' ' + range);
+                continue;
+            }
+            const owner = findPeerOwner(manifests, subject.manifest, gameManifest, peerName);
+            if (owner === undefined) {
+                if (!optionalPeers.has(peerName)) {
+                    notes.push(subject.packageName + ' requires peer ' + peerName + ' ' + range
+                        + '; no direct version was declared. Check the resolved lockfile.');
+                }
+                continue;
+            }
+            const specifier = replacements.get(owner.manifest + '\0' + peerName) ?? owner.specifier;
+            const parsed = parseVersionSpecifier(specifier);
+            if (parsed !== undefined) {
+                if (!intersects(specifier, range)) {
+                    blockers.push(subject.packageName + '@' + subject.latestVersion + ' requires '
+                        + peerName + ' ' + range + ', incompatible with ' + specifier + '.');
+                }
+                else if (!satisfies(parsed.version, range)) {
+                    notes.push(subject.packageName + ' peer ' + peerName + ' requires ' + range
+                        + '; confirm the installed version selected by ' + specifier + '.');
+                }
+            }
+            else if (validRange(specifier) !== null && !intersects(specifier, range)) {
+                blockers.push(subject.packageName + '@' + subject.latestVersion + ' requires '
+                    + peerName + ' ' + range + ', incompatible with ' + specifier + '.');
+            }
+            else if (validRange(specifier) !== null) {
+                const minimum = minVersion(specifier);
+                if (minimum !== null && !satisfies(minimum, range)) {
+                    notes.push(subject.packageName + ' peer ' + peerName + ' requires ' + range
+                        + '; verify the resolved version inside ' + specifier + '.');
+                }
+            }
+            else {
+                notes.push('Could not verify peer ' + peerName + ' for ' + subject.packageName
+                    + ' from specifier ' + specifier + '.');
+            }
+        }
+    }
+}
+function findPeerOwner(manifests, packageManifest, gameManifest, peerName) {
+    for (const manifest of [packageManifest, gameManifest]) {
+        const specifier = dependencySpecifier(manifests.get(manifest), peerName);
+        if (specifier !== undefined) {
+            return { manifest, specifier };
+        }
+    }
+    const candidates = [...manifests].flatMap(([manifest, content]) => {
+        const specifier = dependencySpecifier(content, peerName);
+        return specifier === undefined ? [] : [{ manifest, specifier }];
+    });
+    return candidates.length === 1 ? candidates[0] : undefined;
+}
+function dependencySpecifier(manifest, name) {
+    if (manifest === undefined) {
+        return undefined;
+    }
+    for (const section of dependencySections) {
+        const value = asObject(manifest[section])[name];
+        if (typeof value === 'string') {
+            return value;
+        }
+    }
+    return undefined;
+}
+function parseVersionSpecifier(value) {
+    if (valid(value) !== null) {
+        return { prefix: '', version: value };
+    }
+    const prefix = value[0];
+    if ((prefix === '^' || prefix === '~') && valid(value.slice(1)) !== null) {
+        return { prefix, version: value.slice(1) };
+    }
+    return undefined;
+}
+function updatePnpmLockfile(workspaceRoot) {
+    const result = spawnSync(process.platform === 'win32' ? 'pnpm.cmd' : 'pnpm', ['install', '--lockfile-only', '--ignore-scripts'], {
+        cwd: workspaceRoot,
+        encoding: 'utf8',
+        timeout: 180_000,
+        maxBuffer: 8 * 1024 * 1024,
+        shell: process.platform === 'win32',
+    });
+    if (result.error !== undefined || result.status !== 0) {
+        throw new Error('pnpm lockfile update failed in ' + workspaceRoot + ': '
+            + formatError(result.error ?? (result.stderr || result.stdout)));
+    }
+}
+function parseJsonObject(source, label) {
+    let parsed;
+    try {
+        parsed = JSON.parse(source);
+    }
+    catch (error) {
+        throw new Error('Invalid JSON in ' + label + ': ' + formatError(error));
+    }
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error('Expected a JSON object in ' + label);
+    }
+    return parsed;
+}
+function asObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
+function stringifyLike(original, value) {
+    const indent = original.match(/\r?\n([ \t]+)"/u)?.[1] ?? '  ';
+    const newline = original.includes('\r\n') ? '\r\n' : '\n';
+    return JSON.stringify(value, null, indent).replaceAll('\n', newline)
+        + (original.endsWith('\n') ? newline : '');
+}
+function inside(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative === '' || (!relative.startsWith('..' + path.sep) && relative !== '..'
+        && !path.isAbsolute(relative));
+}
+function digest(source) {
+    return createHash('sha256').update(source).digest('hex');
+}
+function isKitPackageName(name) {
+    return /^@mpgd\/[a-z0-9][a-z0-9._-]*$/u.test(name);
+}
+function formatError(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpgd/cli",
-  "version": "0.34.0",
+  "version": "0.35.0",
   "description": "Gunshi CLI for mpgd-kit starter generation and target workflow orchestration.",
   "license": "MIT",
   "repository": {
@@ -47,25 +47,27 @@
     "entities": "^8.0.0",
     "esbuild": "^0.28.1",
     "gunshi": "^0.35.1",
+    "semver": "^7.8.5",
     "undici": "^7.28.0",
     "@mpgd/phaser-assets": "0.7.0"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",
+    "@types/semver": "^7.8.0",
     "ttsc": "0.30.4",
     "typescript": "7.0.2",
     "@mpgd/adapter-ait": "0.12.5",
+    "@mpgd/adapter-capacitor": "0.5.0",
     "@mpgd/adapter-browser": "0.7.6",
     "@mpgd/adapter-devvit": "0.9.11",
-    "@mpgd/adapter-capacitor": "0.5.0",
     "@mpgd/adapter-verse8": "0.3.9",
+    "@mpgd/analytics": "0.3.15",
     "@mpgd/bridge": "0.10.0",
     "@mpgd/catalog": "0.7.5",
+    "@mpgd/game-services": "0.16.0",
     "@mpgd/i18n": "0.6.4",
     "@mpgd/platform": "0.13.0",
-    "@mpgd/target-config": "0.16.0",
-    "@mpgd/analytics": "0.3.15",
-    "@mpgd/game-services": "0.16.0"
+    "@mpgd/target-config": "0.16.0"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",