@mpgd/cli 0.31.0 → 0.33.0

package/dist/asset-pack-zip.d.ts

@@ -0,0 +1,19 @@
+/**
+* Deterministic ZIP writer for pack delivery archives. The builder targets
+* this limited format only: STORE and DEFLATE entries, no ZIP64, no split
+* archives, no encryption, no directory or symlink entries, no comments.
+* Fixed metadata: DOS timestamp 1980-01-01 00:00:00, UNIX permissions 0644,
+* UTF-8 name flag, no extra fields. Given the same entries in the same order
+* and the same Node/zlib build, the produced bytes are identical.
+*/
+export interface DeterministicZipEntry {
+  /** Normalized relative entry path; validated by the pack format module. */
+  readonly path: string;
+  /** Uncompressed entry bytes. */
+  readonly data: Buffer;
+  readonly method: 'store' | 'deflate';
+  /** Precomputed stored bytes for the entry method, when the builder already
+  * produced them (for example while choosing the method). */
+  readonly stored?: Buffer | undefined;
+}
+export declare function createDeterministicZip(entries: readonly DeterministicZipEntry[]): Buffer;

package/dist/asset-pack-zip.js

@@ -0,0 +1,81 @@
+import { crc32, deflateRawSync } from 'node:zlib';
+const DOS_TIME = 0;
+const DOS_DATE = 0x0021;
+const VERSION_NEEDED = 20;
+const VERSION_MADE_BY = 0x0300;
+const UTF8_FLAG = 0x0800;
+const EXTERNAL_ATTRIBUTES = (0o100644 << 16) >>> 0;
+const MAX_ENTRIES = 0xffff;
+const MAX_ENTRY_BYTES = 0xffffffff;
+export function createDeterministicZip(entries) {
+    if (entries.length === 0 || entries.length > MAX_ENTRIES) {
+        throw new Error(`Deterministic ZIP requires 1..${MAX_ENTRIES} entries`);
+    }
+    const localChunks = [];
+    const centralChunks = [];
+    let offset = 0;
+    for (const entry of entries) {
+        const name = Buffer.from(entry.path, 'utf8');
+        if (name.length > MAX_ENTRIES) {
+            throw new Error(`Deterministic ZIP entry name exceeds 65535 bytes: ${entry.path}`);
+        }
+        if (entry.data.length > MAX_ENTRY_BYTES) {
+            throw new Error(`Deterministic ZIP entry exceeds 4 GiB: ${entry.path}`);
+        }
+        const compressed = entry.method === 'deflate'
+            ? (entry.stored ?? deflateRawSync(entry.data, { level: 9 }))
+            : entry.data;
+        if (compressed.length > MAX_ENTRY_BYTES) {
+            throw new Error(`Deterministic ZIP entry exceeds 4 GiB: ${entry.path}`);
+        }
+        const methodCode = entry.method === 'deflate' ? 8 : 0;
+        const digest = crc32(entry.data) >>> 0;
+        const local = Buffer.alloc(30);
+        local.writeUInt32LE(0x04034b50, 0);
+        local.writeUInt16LE(VERSION_NEEDED, 4);
+        local.writeUInt16LE(UTF8_FLAG, 6);
+        local.writeUInt16LE(methodCode, 8);
+        local.writeUInt16LE(DOS_TIME, 10);
+        local.writeUInt16LE(DOS_DATE, 12);
+        local.writeUInt32LE(digest, 14);
+        local.writeUInt32LE(compressed.length, 18);
+        local.writeUInt32LE(entry.data.length, 22);
+        local.writeUInt16LE(name.length, 26);
+        local.writeUInt16LE(0, 28);
+        localChunks.push(local, name, compressed);
+        const central = Buffer.alloc(46);
+        central.writeUInt32LE(0x02014b50, 0);
+        central.writeUInt16LE(VERSION_MADE_BY, 4);
+        central.writeUInt16LE(VERSION_NEEDED, 6);
+        central.writeUInt16LE(UTF8_FLAG, 8);
+        central.writeUInt16LE(methodCode, 10);
+        central.writeUInt16LE(DOS_TIME, 12);
+        central.writeUInt16LE(DOS_DATE, 14);
+        central.writeUInt32LE(digest, 16);
+        central.writeUInt32LE(compressed.length, 20);
+        central.writeUInt32LE(entry.data.length, 24);
+        central.writeUInt16LE(name.length, 28);
+        central.writeUInt16LE(0, 30);
+        central.writeUInt16LE(0, 32);
+        central.writeUInt16LE(0, 34);
+        central.writeUInt16LE(0, 36);
+        central.writeUInt32LE(EXTERNAL_ATTRIBUTES, 38);
+        central.writeUInt32LE(offset, 42);
+        centralChunks.push(central, name);
+        offset += local.length + name.length + compressed.length;
+    }
+    const centralDirectory = Buffer.concat(centralChunks);
+    if (offset > MAX_ENTRY_BYTES || centralDirectory.length > MAX_ENTRY_BYTES) {
+        throw new Error('Deterministic ZIP archive exceeds 4 GiB');
+    }
+    const end = Buffer.alloc(22);
+    end.writeUInt32LE(0x06054b50, 0);
+    end.writeUInt16LE(0, 4);
+    end.writeUInt16LE(0, 6);
+    end.writeUInt16LE(entries.length, 8);
+    end.writeUInt16LE(entries.length, 10);
+    end.writeUInt32LE(centralDirectory.length, 12);
+    end.writeUInt32LE(offset, 16);
+    end.writeUInt16LE(0, 20);
+    return Buffer.concat([...localChunks, centralDirectory, end]);
+}

package/dist/bin.js

@@ -1,3 +1,8 @@
 #!/usr/bin/env node
-import { readCliArgs, runMpgdCli } from './index.js';
+import { mpgdCliNeedsForcedExit, readCliArgs, runMpgdCli } from './index.js';
 await runMpgdCli(readCliArgs());
+if (mpgdCliNeedsForcedExit()) {
+    // Stalled threadpool filesystem work cannot be cancelled; only the
+    // standalone binary may terminate the process to outrun it.
+    process.exit(process.exitCode ?? 1);
+}

package/dist/cloudflare-pages-static.js

@@ -9,7 +9,7 @@
  * being silently ignored.
  */
 const maximumHeaderBlocks = 100;
-const maximumLineLength = 2000;
+const maximumLineLength = 2_000;
 const supportedRedirectCodes = new Set([301, 302, 303, 307, 308]);
 export function parseCloudflarePagesHeaders(input) {
     const lines = input.replaceAll('\r\n', '\n').replaceAll('\r', '\n').split('\n');

package/dist/evidence-io.js

@@ -38,7 +38,7 @@ export function escapeMarkdownInline(value) {
         .replaceAll('\n', ' ');
 }
 export function formatDuration(durationMs) {
-    return durationMs < 1000 ? `${durationMs}ms` : `${(durationMs / 1000).toFixed(1)}s`;
+    return durationMs < 1_000 ? `${durationMs}ms` : `${(durationMs / 1_000).toFixed(1)}s`;
 }
 export function formatError(error) {
     return error instanceof Error ? error.message : String(error);

package/dist/game-acceptance.js

@@ -3,9 +3,9 @@ import { existsSync, mkdirSync, rmSync } from 'node:fs';
 import path from 'node:path';
 import { escapeMarkdownInline, escapeMarkdownTable, formatDuration, formatError, readBoundedUtf8File, relativeOrAbsolute, writeEvidenceReportFiles, } from './evidence-io.js';
 import { collectGameplayE2EPathEvidence, maximumGameplayE2EStates, readGameplayE2EPlan, resolveGameplayE2EPathInsideGameRoot, } from './gameplay-e2e.js';
-export const defaultGameAcceptanceCommandTimeoutMs = 30 * 60 * 1000;
+export const defaultGameAcceptanceCommandTimeoutMs = 30 * 60 * 1_000;
 const defaultGameAcceptanceReleaseManifestFile = 'artifacts/release-manifest.json';
-export const maximumGameplayE2EReportBytes = 1024 * 1024;
+export const maximumGameplayE2EReportBytes = 1_024 * 1_024;
 export function resolveGameAcceptanceReleaseManifestFile(gameRoot, env = process.env) {
     const configuredFile = env.MPGD_RELEASE_MANIFEST_FILE;
     return path.resolve(gameRoot, configuredFile === undefined || configuredFile.length === 0

package/dist/gameplay-e2e.js

@@ -7,13 +7,13 @@ const gameplayStateIdPattern = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
 const gameplayKeyControlCharacterPattern = /[\u0000-\u001f\u007f]/u;
 export const maximumGameplayE2EStates = 50;
 const maximumActionsPerState = 100;
-const maximumWaitMs = 60000;
-const maximumBackgroundMs = 5 * 60000;
-const maximumHashReadChunkBytes = 64 * 1024;
+const maximumWaitMs = 60_000;
+const maximumBackgroundMs = 5 * 60_000;
+const maximumHashReadChunkBytes = 64 * 1_024;
 const defaultGameplayE2EHashLimits = {
     maximumDepth: 128,
-    maximumEntries: 100000,
-    maximumTotalFileBytes: 4 * 1024 * 1024 * 1024,
+    maximumEntries: 100_000,
+    maximumTotalFileBytes: 4 * 1_024 * 1_024 * 1_024,
 };
 class GameplayE2EAggregatedError extends Error {
     errors;

package/dist/hosted-pwa-deployment.js

@@ -966,7 +966,7 @@ function decodeCssEscapes(value) {
             return plain ?? '';
         }
         const codePoint = Number.parseInt(hex, 16);
-        return codePoint > 1114111 || Number.isNaN(codePoint)
+        return codePoint > 0x10_ffff || Number.isNaN(codePoint)
             ? '\uFFFD'
             : String.fromCodePoint(codePoint);
     });
@@ -1161,9 +1161,7 @@ function verifyCloudflarePagesHeaders(deploymentRoot, sourceFiles, deploymentFil
         if (sourcePaths.has(file.slice(1))) {
             requirements.push({
                 requestPath: file,
-                expected: noStoreCacheControlFiles.has(file)
-                    ? noStoreCacheControl
-                    : freshCacheControl,
+                expected: noStoreCacheControlFiles.has(file) ? noStoreCacheControl : freshCacheControl,
                 label: file.slice(1),
             });
         }

package/dist/index.d.ts

@@ -8,6 +8,7 @@ export { createMicrosoftStorePackageAcceptanceRuntime, microsoftStorePackageAcce
 export { createMicrosoftStorePackageGenerationRuntime, microsoftStorePackageGeneratorEndpoint, microsoftStorePackageGeneratorSourceRevision, microsoftStorePackageGenerationSchemaVersion, renderMicrosoftStorePackageGenerationMarkdown, runMicrosoftStorePackageGeneration, type CreateMicrosoftStorePackageGenerationRuntimeInput, type MicrosoftStoreAddressResolver, type MicrosoftStorePackageGenerationEvidence, type MicrosoftStorePackageGenerationRuntime, type MicrosoftStoreResolvedAddress, type RunMicrosoftStorePackageGenerationInput, } from './microsoft-store-package-generation.js';
 export { microsoftStoreSubmissionSchemaVersion, parseMicrosoftStoreSubmissionConfig, renderMicrosoftStoreSubmissionMarkdown, runMicrosoftStoreSubmissionPreflight, type MicrosoftStoreSubmissionConfig, type MicrosoftStoreSubmissionCommerce, type MicrosoftStoreSubmissionCommerceProduct, type MicrosoftStoreSubmissionEvidence, type RunMicrosoftStoreSubmissionPreflightInput, } from './microsoft-store-submission.js';
 export { assertProductionTargetReadiness, type ProductionTargetReadinessInput, } from './production-target-readiness.js';
+export declare function mpgdCliNeedsForcedExit(): boolean;
 export declare function runMpgdCli(args: readonly string[]): Promise<void>;
 export declare function runCreateGameCli(args: readonly string[]): Promise<void>;
 export declare function readCliArgs(): readonly string[];

package/dist/index.js

@@ -6,6 +6,8 @@ import completion from '@gunshi/plugin-completion';
 import i18n, { defineI18n } from '@gunshi/plugin-i18n';
 import resources from '@gunshi/resources';
 import { cli } from 'gunshi';
+import { buildAssetPacks } from './asset-pack-build.js';
+import { verifyAssetPackDelivery } from './asset-pack-verify.js';
 import { normalizeConfiguredBuildTargets, normalizeBuildTarget as normalizeConfiguredTargetName, supportedBuildTargets, } from './build-targets.js';
 import { escapeMarkdownInline as escapeEvidenceMarkdownInline, writeEvidenceReportFiles, } from './evidence-io.js';
 import { defaultGameAcceptanceCommandTimeoutMs, resolveGameAcceptanceReleaseManifestFile, runGameAcceptance, } from './game-acceptance.js';
@@ -85,11 +87,71 @@ const acceptanceStepIds = {
     targetSmoke: 'target-smoke',
     gameplayE2E: 'gameplay-e2e',
 };
+/** Whether the last run reported a deadline failure that leaves
+ * uncancellable filesystem work pending: the standalone binary forces its
+ * exit (see bin.ts); in-process library callers handle it themselves. */
+let forcedExitPending = false;
+/** A blocked pipe must not prevent the standalone binary from reaching its
+ * forced-exit path after a deadline report. The callback may remain queued
+ * behind a stalled reader, so the drain is best effort and bounded. */
+const CLI_OUTPUT_DRAIN_TIMEOUT_MS = 250;
+const drainOutput = (stream) => new Promise((resolve) => {
+    let settled = false;
+    const finish = () => {
+        if (settled) {
+            return;
+        }
+        settled = true;
+        resolve();
+    };
+    const timer = setTimeout(finish, CLI_OUTPUT_DRAIN_TIMEOUT_MS);
+    try {
+        stream.write('', () => {
+            clearTimeout(timer);
+            finish();
+        });
+    }
+    catch {
+        clearTimeout(timer);
+        finish();
+    }
+});
+export function mpgdCliNeedsForcedExit() {
+    return forcedExitPending;
+}
 export async function runMpgdCli(args) {
+    forcedExitPending = false;
     await cli([...args], entryCommand, {
         name: 'mpgd',
         version: cliVersion,
+        // Machine-readable mode contract: `assets verify-delivery --json`
+        // owns stdout entirely — exactly one JSON document, parseable with
+        // JSON.parse(stdout) and nothing else. The framework's banner is
+        // suppressed for that command, and framework-level argument errors
+        // (bad value types, missing required arguments — rejected before the
+        // command handler runs) move to stderr so stdout never carries a
+        // partial document. Every other command keeps the default rendering.
+        renderHeader: async (ctx) => {
+            const values = ctx.values;
+            if (ctx.name === 'verify-delivery' && values.json === true) {
+                return '';
+            }
+            const title = ctx.env.description || ctx.env.name || '';
+            return title
+                ? `${title} (${ctx.env.name || ''}${ctx.env.version ? ` v${ctx.env.version}` : ''})`
+                : title;
+        },
+        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) {
+                process.stderr.write(`${messages}\n`);
+                return '';
+            }
+            return messages;
+        },
         subCommands: {
+            assets: assetsCommand,
             game: gameCommand,
             legal: legalCommand,
             target: targetCommand,
@@ -143,7 +205,7 @@ const entryCommand = defineI18n({
         ko: 'mpgd-kit 스타터와 타깃 워크플로우를 관리합니다.',
     }),
     run: () => {
-        console.info('Use a sub-command: game, target, kit.');
+        console.info('Use a sub-command: assets, game, legal, target, kit.');
         console.info('Run "pnpm mpgd --help" for available commands.');
     },
 });
@@ -774,6 +836,226 @@ function readPositiveInteger(value, label) {
     }
     return parsed;
 }
+function assetPackVerifyArgs() {
+    return {
+        manifest: {
+            type: 'string',
+            required: true,
+            description: 'Path to the delivery manifest JSON document.',
+        },
+        root: {
+            type: 'string',
+            required: true,
+            description: 'Deployment root the manifest artifact paths resolve against.',
+        },
+        json: {
+            type: 'boolean',
+            required: false,
+            description: 'Print a single machine-readable JSON report to stdout.',
+        },
+        'max-object-bytes': {
+            type: 'number',
+            required: false,
+            description: 'Optional static-host limit: largest allowed deployed object in bytes.',
+        },
+        'max-files': {
+            type: 'number',
+            required: false,
+            description: 'Optional static-host limit: total regular files allowed under the root.',
+        },
+        'max-total-bytes': {
+            type: 'number',
+            required: false,
+            description: 'Optional static-host limit: total deployed bytes allowed under the root.',
+        },
+        'max-archive-bytes': {
+            type: 'number',
+            required: false,
+            description: 'Optional cap: largest zip archive read for verification, in bytes.',
+        },
+        'max-entry-bytes': {
+            type: 'number',
+            required: false,
+            description: 'Optional cap: largest expanded zip entry allowed, in bytes.',
+        },
+        'max-expanded-bytes': {
+            type: 'number',
+            required: false,
+            description: 'Optional cap: total expanded bytes allowed per archive, in bytes.',
+        },
+    };
+}
+function assetPackBuildArgs() {
+    return {
+        config: {
+            type: 'string',
+            required: true,
+            description: 'Path to the asset pack build config JSON file.',
+        },
+        out: {
+            type: 'string',
+            required: true,
+            description: 'Output directory for delivery artifacts, outside the source root.',
+        },
+    };
+}
+const assetsCommand = defineI18n({
+    name: 'assets',
+    description: 'Build deterministic asset pack delivery artifacts.',
+    resource: commandResource({
+        en: 'Build deterministic asset pack delivery artifacts.',
+        ko: '결정적인 에셋 팩 전달 산출물을 빌드합니다.',
+    }),
+    subCommands: {
+        'build-packs': defineI18n({
+            name: 'build-packs',
+            description: 'Build files or ZIP delivery artifacts for configured packs.',
+            resource: commandResource({
+                en: 'Build files or ZIP delivery artifacts for configured packs.',
+                ko: '설정된 팩의 files 또는 ZIP 전달 산출물을 빌드합니다.',
+            }, {
+                config: {
+                    en: 'Path to the asset pack build config JSON file.',
+                    ko: '에셋 팩 빌드 설정 JSON 파일 경로.',
+                },
+                out: {
+                    en: 'Output directory for delivery artifacts, outside the source root.',
+                    ko: '전달 산출물 출력 디렉터리. 소스 루트 밖이어야 합니다.',
+                },
+            }),
+            args: assetPackBuildArgs(),
+            run: (ctx) => {
+                const report = buildAssetPacks({
+                    configPath: ctx.values.config,
+                    outDir: ctx.values.out,
+                });
+                for (const output of report.outputs) {
+                    console.info(`${output.action === 'written' ? 'wrote' : 'unchanged'} ${output.path} `
+                        + `(${output.bytes} bytes, sha256:${output.sha256})`);
+                }
+                for (const archive of report.archives) {
+                    console.info(`archive ${archive.path}: ${archive.entryCount} entries `
+                        + `(${archive.storeEntries} store, ${archive.deflateEntries} deflate), `
+                        + `sources ${archive.sourceBytes} bytes, archive ${archive.archiveBytes} bytes, `
+                        + `sha256:${archive.sha256}`);
+                }
+                console.info(`Asset pack delivery manifest: ${report.manifestPath}`);
+            },
+        }),
+        'verify-delivery': defineI18n({
+            name: 'verify-delivery',
+            description: 'Verify delivery artifacts read-only against the manifest.',
+            resource: commandResource({
+                en: 'Verify delivery artifacts read-only against the manifest.',
+                ko: '전달 산출물을 manifest 기준으로 읽기 전용으로 검증합니다.',
+            }, {
+                manifest: {
+                    en: 'Path to the delivery manifest JSON document.',
+                    ko: '전달 manifest JSON 문서 경로.',
+                },
+                root: {
+                    en: 'Deployment root the manifest artifact paths resolve against.',
+                    ko: 'manifest 산출물 경로의 기준이 되는 배포 루트 디렉터리.',
+                },
+                json: {
+                    en: 'Print a single machine-readable JSON report to stdout.',
+                    ko: '기계 판독 가능한 JSON 보고서 하나를 stdout에 출력합니다.',
+                },
+                'max-object-bytes': {
+                    en: 'Optional static-host limit: largest allowed deployed object in bytes.',
+                    ko: '선택적 정적 호스트 한도: 허용되는 최대 배포 object 바이트 수.',
+                },
+                'max-files': {
+                    en: 'Optional static-host limit: total regular files allowed under the root.',
+                    ko: '선택적 정적 호스트 한도: 루트 아래 허용되는 일반 파일 총 개수.',
+                },
+                'max-total-bytes': {
+                    en: 'Optional static-host limit: total deployed bytes allowed under the root.',
+                    ko: '선택적 정적 호스트 한도: 루트 아래 허용되는 총 배포 바이트 수.',
+                },
+                'max-archive-bytes': {
+                    en: 'Optional cap: largest zip archive read for verification, in bytes.',
+                    ko: '선택적 상한: 검증 시 읽는 zip 아카이브의 최대 바이트 수.',
+                },
+                'max-entry-bytes': {
+                    en: 'Optional cap: largest expanded zip entry allowed, in bytes.',
+                    ko: '선택적 상한: 허용되는 확장(zip 해제) 엔트리 최대 바이트 수.',
+                },
+                'max-expanded-bytes': {
+                    en: 'Optional cap: total expanded bytes allowed per archive, in bytes.',
+                    ko: '선택적 상한: 아카이브별 허용되는 총 확장 바이트 수.',
+                },
+            }),
+            args: assetPackVerifyArgs(),
+            run: async (ctx) => {
+                const hostLimits = {
+                    ...(ctx.values['max-object-bytes'] === undefined
+                        ? {}
+                        : { maxObjectBytes: ctx.values['max-object-bytes'] }),
+                    ...(ctx.values['max-files'] === undefined
+                        ? {}
+                        : { maxFiles: ctx.values['max-files'] }),
+                    ...(ctx.values['max-total-bytes'] === undefined
+                        ? {}
+                        : { maxTotalBytes: ctx.values['max-total-bytes'] }),
+                };
+                const report = await verifyAssetPackDelivery({
+                    manifestPath: ctx.values.manifest,
+                    root: ctx.values.root,
+                    ...(Object.keys(hostLimits).length > 0 ? { hostLimits } : {}),
+                    ...(ctx.values['max-archive-bytes'] === undefined
+                        ? {}
+                        : { maxArchiveBytes: ctx.values['max-archive-bytes'] }),
+                    ...(ctx.values['max-entry-bytes'] === undefined
+                        ? {}
+                        : { maxEntryBytes: ctx.values['max-entry-bytes'] }),
+                    ...(ctx.values['max-expanded-bytes'] === undefined
+                        ? {}
+                        : { maxExpandedBytes: ctx.values['max-expanded-bytes'] }),
+                });
+                if (ctx.values.json === true) {
+                    console.info(JSON.stringify(report, null, 2));
+                }
+                else {
+                    for (const archive of report.archives) {
+                        console.info(`verified archive ${archive.packId}: ${archive.entries} entries, ${archive.expandedBytes} expanded bytes`);
+                    }
+                    console.info(`manifest ${report.manifest.sha256.slice(0, 12)}… (${report.manifest.bytes} bytes, ${report.manifest.packs} packs)`);
+                    console.info(`referenced objects: ${report.referenced.files} files, ${report.referenced.bytes} bytes`);
+                    if (report.inventory !== undefined) {
+                        console.info(`root inventory: ${report.inventory.files} files, ${report.inventory.bytes} bytes${report.inventory.truncated ? ' (truncated)' : ''}`);
+                    }
+                    for (const failure of report.failures) {
+                        console.error(`[${failure.stage}/${failure.code}] ${failure.message}`);
+                    }
+                    if (report.ok) {
+                        console.info('Delivery verification passed.');
+                    }
+                    else {
+                        console.error('Delivery verification failed; see the failures above.');
+                    }
+                }
+                if (report.failures.some((failure) => failure.code === 'deadline')) {
+                    // Piped console output is asynchronous; drain both streams so a
+                    // large report is not truncated by the binary's forced exit.
+                    await Promise.all([drainOutput(process.stdout), drainOutput(process.stderr)]);
+                    // Stalled filesystem requests cannot be cancelled once the
+                    // deadline fires; the standalone binary forces its exit so a
+                    // pending threadpool call cannot keep the process (and its
+                    // leaked handle) alive past the reported budget. In-process
+                    // callers of runMpgdCli observe mpgdCliNeedsForcedExit instead.
+                    forcedExitPending = true;
+                }
+                if (!report.ok) {
+                    process.exitCode = 1;
+                }
+            },
+        }),
+    },
+    run: () => {
+        console.info('Use "mpgd assets build-packs" or "mpgd assets verify-delivery".');
+    },
+});
 const legalCommand = defineI18n({
     name: 'legal',
     description: 'Build static legal/support pages for store and release evidence.',
@@ -1910,9 +2192,7 @@ function createGameApp(input) {
             relativePath: file.relativePath,
             content: file.content,
         });
-        return prepared === undefined
-            ? []
-            : [{ ...file, content: renderTemplate(prepared, context) }];
+        return prepared === undefined ? [] : [{ ...file, content: renderTemplate(prepared, context) }];
     });
     if (input.dryRun) {
         console.info(`Would create ${path.relative(process.cwd(), appDir) || appDir}:`);
@@ -2003,8 +2283,17 @@ function createTemplateContext(input) {
     if (input.workspace && kitPath === undefined) {
         throw new Error('Could not detect an mpgd-kit checkout for --workspace. Pass --kit-path or set MPGD_KIT_PATH.');
     }
-    const workspaceRoot = toTemplatePath(path.relative(input.appDir, kitPath ?? input.appDir) || '.');
+    const relativeKitPath = path.relative(input.appDir, kitPath ?? input.appDir);
+    if (input.workspace && path.isAbsolute(relativeKitPath)) {
+        throw new Error('--workspace requires the game and mpgd-kit to share a filesystem root.');
+    }
+    const workspaceRoot = toTemplatePath(relativeKitPath || '.');
     const workspacePrefix = workspaceRoot;
+    // The normalized relative path's parent hops reach the common source root.
+    // Do not inherit the kit's narrower root when the game is a sibling checkout.
+    const tsconfigRootDir = input.workspace
+        ? workspacePrefix.split('/').filter((segment) => segment === '..').join('/') || '.'
+        : '.';
     const mpgdDependencyVersionReplacements = resolveMpgdDependencyVersionReplacements({
         ...(input.dependencyVersion === undefined
             ? {}
@@ -2025,6 +2314,7 @@ function createTemplateContext(input) {
         tsconfigExtendsLine: input.workspace
             ? `  "extends": "${workspacePrefix}/tsconfig.base.json",`
             : '',
+        tsconfigRootDir,
         tsconfigWorkspaceIncludes: input.workspace
             ? [
                 `,\n    "${workspacePrefix}/packages/**/*.ts"`,
@@ -2142,6 +2432,7 @@ function renderTemplate(content, context) {
         .replaceAll('__PACKAGE_NAME__', context.packageName)
         .replaceAll('__MPGD_DEPENDENCY_VERSION__', context.defaultDependencyVersion)
         .replaceAll('__TSCONFIG_EXTENDS_LINE__', context.tsconfigExtendsLine)
+        .replaceAll('__TSCONFIG_ROOT_DIR__', context.tsconfigRootDir)
         .replaceAll('__TSCONFIG_WORKSPACE_INCLUDES__', context.tsconfigWorkspaceIncludes)
         .replaceAll('__TSCONFIG_WORKSPACE_EXCLUDES__', context.tsconfigWorkspaceExcludes)
         .replaceAll('__WORKSPACE_I18N_BUILD_PREFIX__', context.workspaceI18nBuildPrefix)

package/dist/microsoft-store-package-acceptance.js

@@ -6,7 +6,7 @@ import path from 'node:path';
 import { escapeMarkdownInline, escapeMarkdownTable, formatError, relativeOrAbsolute, } from './evidence-io.js';
 export const microsoftStorePackageAcceptanceSchemaVersion = 1;
 const supportedPackageExtensions = ['.appx', '.appxbundle', '.msix', '.msixbundle'];
-const maximumWindowsPackageCommandDurationMs = 60 * 60 * 1000;
+const maximumWindowsPackageCommandDurationMs = 60 * 60 * 1_000;
 const maximumWindowsPackageCommandOutputBytes = 16 * 1024 * 1024;
 const maximumWindowsPackageCommandDiagnosticCharacters = 8 * 1024;
 const xmlNamedEntities = {

package/dist/microsoft-store-package-generation-download.js

@@ -11,9 +11,9 @@ import { assertMicrosoftStorePackageZip } from './microsoft-store-package-genera
 const maximumManifestBytes = 1024 * 1024;
 const maximumManifestIconBytes = 2 * 1024 * 1024;
 const maximumArchiveBytes = 512 * 1024 * 1024;
-const manifestRequestTimeoutMs = 30000;
-const manifestIconRequestTimeoutMs = 30000;
-const packageRequestTimeoutMs = 10 * 60 * 1000;
+const manifestRequestTimeoutMs = 30_000;
+const manifestIconRequestTimeoutMs = 30_000;
+const packageRequestTimeoutMs = 10 * 60 * 1_000;
 const blockedIpv4Addresses = createBlockedIpv4Addresses();
 const blockedIpv6Addresses = createBlockedIpv6Addresses();
 const allowedIpv6GlobalUnicastAddresses = createAllowedIpv6GlobalUnicastAddresses();

package/dist/microsoft-store-package-generation-input.js

@@ -261,7 +261,7 @@ function requireStorePackageVersion(input, label) {
     }
     const numbers = parts.map(Number);
     if (numbers[0] === 0
-        || numbers.some((part) => part > 65535)
+        || numbers.some((part) => part > 65_535)
         || (numbers[3] ?? 0) !== 0) {
         throw new Error(`${label} must start from 1, keep every part at or below 65535, and end in .0.`);
     }

package/dist/microsoft-store-package-generation-zip.js

@@ -10,7 +10,7 @@ export function assertMicrosoftStorePackageZip(file, sizeBytes) {
         if (header.readUInt32LE(0) !== 0x04034b50) {
             throw new Error('PWABuilder package archive must start with a ZIP local file header.');
         }
-        const tailLength = Math.min(sizeBytes, 65557);
+        const tailLength = Math.min(sizeBytes, 65_557);
         const tail = Buffer.allocUnsafe(tailLength);
         readExactly(descriptor, tail, sizeBytes - tailLength);
         const endOffset = findEndOfCentralDirectory(tail);

package/dist/microsoft-store-submission.js

@@ -7,7 +7,7 @@ import { escapeMarkdownInline, escapeMarkdownTable, formatError, relativeOrAbsol
 import { isMicrosoftStoreSupportedListingLocale } from './microsoft-store-supported-locales.js';
 export const microsoftStoreSubmissionSchemaVersion = 1;
 // Microsoft Store listing and package identity limits documented by Microsoft Learn.
-const maximumStoreDescriptionCharacters = 10000;
+const maximumStoreDescriptionCharacters = 10_000;
 const maximumStoreDesktopScreenshots = 10;
 const maximumStoreManifestIcons = 32;
 const maximumStoreScreenshotBytes = 50 * 1024 * 1024;
@@ -907,20 +907,20 @@ function pngPassLength(size, start, step) {
     return size <= start ? 0 : Math.ceil((size - start) / step);
 }
 function crc32Png(parts) {
-    let crc = 4294967295;
+    let crc = 0xffff_ffff;
     for (const part of parts) {
         for (const byte of part) {
             crc = (crc >>> 8) ^ (pngCrc32Table[(crc ^ byte) & 0xff] ?? 0);
         }
     }
-    return (crc ^ 4294967295) >>> 0;
+    return (crc ^ 0xffff_ffff) >>> 0;
 }
 function createPngCrc32Table() {
     const table = new Uint32Array(256);
     for (let value = 0; value < table.length; value += 1) {
         let crc = value;
         for (let bit = 0; bit < 8; bit += 1) {
-            crc = (crc >>> 1) ^ (crc & 1 ? 3988292384 : 0);
+            crc = (crc >>> 1) ^ (crc & 1 ? 0xedb8_8320 : 0);
         }
         table[value] = crc >>> 0;
     }