@mpgd/cli 0.6.0 → 0.7.0

package/dist/index.js

@@ -6,6 +6,9 @@ import completion from '@gunshi/plugin-completion';
 import i18n, { defineI18n } from '@gunshi/plugin-i18n';
 import resources from '@gunshi/resources';
 import { cli } from 'gunshi';
+import { defaultGameAcceptanceCommandTimeoutMs, resolveGameAcceptanceReleaseManifestFile, runGameAcceptance, } from './game-acceptance.js';
+export { renderGameAcceptanceMarkdown, resolveGameAcceptanceReleaseManifestFile, runGameAcceptance, defaultGameAcceptanceCommandTimeoutMs, } from './game-acceptance.js';
+export { assertProductionTargetReadiness, } from './production-target-readiness.js';
 const sourceDir = path.dirname(fileURLToPath(import.meta.url));
 const packageRoot = resolvePackageRoot(sourceDir);
 const detectedKitRoot = resolveDefaultKitRoot();
@@ -50,6 +53,15 @@ const supportedBuildTargets = [
     'reddit',
 ];
 const supportedVariants = ['wrapper', 'sync', 'simulator', 'archive'];
+const acceptanceStepIds = {
+    check: 'check',
+    test: 'test',
+    build: 'build',
+    graph: 'graph-preflight',
+    playtest: 'playtest',
+    targetBuild: 'target-build',
+    targetSmoke: 'target-smoke',
+};
 export async function runMpgdCli(args) {
     await cli([...args], entryCommand, {
         name: 'mpgd',
@@ -213,15 +225,402 @@ const gameCommand = defineI18n({
                 });
             },
         }),
+        accept: defineI18n({
+            name: 'accept',
+            description: 'Run the reusable game handoff acceptance workflow.',
+            resource: commandResource({
+                en: 'Run check, test, build, graph, playtest, and target acceptance with handoff reports.',
+                ko: 'check, test, build, graph, playtest, 타깃 인수 검증과 인계 리포트를 실행합니다.',
+            }, {
+                game: {
+                    en: 'Game root containing package.json and mpgd.targets.json.',
+                    ko: 'package.json과 mpgd.targets.json이 있는 게임 루트.',
+                },
+                targets: {
+                    en: 'Comma-separated target list, default, or all.',
+                    ko: '쉼표로 구분한 타깃 목록, default 또는 all.',
+                },
+                profile: {
+                    en: 'Target build profile. Defaults to staging.',
+                    ko: '타깃 빌드 프로필. 기본값은 staging.',
+                },
+                'playtest-script': {
+                    en: 'Optional game-owned package script used for automated playtesting.',
+                    ko: '자동 플레이테스트에 사용할 선택적 게임 소유 패키지 스크립트.',
+                },
+                'report-dir': {
+                    en: 'JSON and Markdown handoff report directory.',
+                    ko: 'JSON 및 Markdown 인계 리포트 디렉터리.',
+                },
+                'timeout-ms': {
+                    en: 'Maximum duration for each acceptance command.',
+                    ko: '각 인수 검증 명령의 최대 실행 시간.',
+                },
+                'kit-path': {
+                    en: 'Path to the mpgd-kit checkout.',
+                    ko: 'mpgd-kit 체크아웃 경로.',
+                },
+            }),
+            args: {
+                game: {
+                    type: 'positional',
+                    required: true,
+                    description: 'Game root containing package.json and mpgd.targets.json.',
+                },
+                targets: {
+                    type: 'string',
+                    required: false,
+                    default: 'default',
+                    description: 'Comma-separated target list, default, or all.',
+                },
+                profile: {
+                    type: 'string',
+                    required: false,
+                    default: 'staging',
+                    description: 'Target build profile.',
+                },
+                'ait-variant': {
+                    type: 'enum',
+                    choices: supportedVariants,
+                    required: false,
+                    default: 'wrapper',
+                    description: 'Variant for the ait target.',
+                },
+                'ios-variant': {
+                    type: 'enum',
+                    choices: supportedVariants,
+                    required: false,
+                    description: 'Variant for the ios target.',
+                },
+                'playtest-script': {
+                    type: 'string',
+                    required: false,
+                    default: 'playtest',
+                    description: 'Game-owned package script used for automated playtesting.',
+                },
+                'report-dir': {
+                    type: 'string',
+                    required: false,
+                    description: 'JSON and Markdown handoff report directory.',
+                },
+                'timeout-ms': {
+                    type: 'string',
+                    required: false,
+                    default: String(defaultGameAcceptanceCommandTimeoutMs),
+                    description: 'Maximum duration for each acceptance command in milliseconds.',
+                },
+                'kit-path': {
+                    type: 'string',
+                    required: false,
+                    description: 'Path to the mpgd-kit checkout.',
+                },
+                'skip-test': {
+                    type: 'boolean',
+                    required: false,
+                    description: 'Skip the game-owned test package script.',
+                },
+                'skip-graph': {
+                    type: 'boolean',
+                    required: false,
+                    description: 'Skip the kit graph preflight.',
+                },
+                'skip-playtest': {
+                    type: 'boolean',
+                    required: false,
+                    description: 'Skip the game-owned playtest package script.',
+                },
+                'skip-target-build': {
+                    type: 'boolean',
+                    required: false,
+                    description: 'Skip the target build matrix.',
+                },
+                'skip-target-smoke': {
+                    type: 'boolean',
+                    required: false,
+                    description: 'Skip the target smoke matrix.',
+                },
+            },
+            run: (ctx) => {
+                const positionals = readLocalPositionals(ctx.positionals, ['game', 'accept']);
+                const gameRoot = path.resolve(readRequiredPositional(positionals, 0, 'game'));
+                const iosVariant = readOptionalString(ctx.values['ios-variant']);
+                const reportDir = readOptionalString(ctx.values['report-dir']);
+                const kitPath = readOptionalString(ctx.values['kit-path']);
+                const timeoutMs = readPositiveInteger(readOptionalString(ctx.values['timeout-ms'])
+                    ?? String(defaultGameAcceptanceCommandTimeoutMs), '--timeout-ms');
+                acceptGame({
+                    gameRoot,
+                    targets: readOptionalString(ctx.values.targets) ?? 'default',
+                    profile: readOptionalString(ctx.values.profile) ?? 'staging',
+                    aitVariant: readOptionalString(ctx.values['ait-variant']) ?? 'wrapper',
+                    ...(iosVariant === undefined ? {} : { iosVariant }),
+                    playtestScript: readOptionalString(ctx.values['playtest-script']) ?? 'playtest',
+                    ...(reportDir === undefined ? {} : { reportDir }),
+                    ...(kitPath === undefined ? {} : { kitPath }),
+                    timeoutMs,
+                    skipTest: ctx.values['skip-test'] === true,
+                    skipGraph: ctx.values['skip-graph'] === true,
+                    skipPlaytest: ctx.values['skip-playtest'] === true,
+                    skipTargetBuild: ctx.values['skip-target-build'] === true,
+                    skipTargetSmoke: ctx.values['skip-target-smoke'] === true,
+                });
+            },
+        }),
+        icons: defineI18n({
+            name: 'icons',
+            description: 'Generate and verify target app icons from the game brand source.',
+            resource: commandResource({
+                en: 'Generate and verify target app icons from the game brand source.',
+                ko: '게임 브랜드 원본에서 타깃별 앱 아이콘을 생성하고 검증합니다.',
+            }),
+            subCommands: Object.fromEntries(['generate', 'verify', 'inspect'].map((action) => [
+                action,
+                defineI18n({
+                    name: action,
+                    description: `${action} target app icon assets.`,
+                    resource: commandResource({
+                        en: `${action} target app icon assets.`,
+                        ko: `타깃 앱 아이콘 자산을 ${action}합니다.`,
+                    }),
+                    args: {
+                        game: {
+                            type: 'positional',
+                            required: true,
+                            description: 'Game root containing mpgd.game.json and mpgd.targets.json.',
+                        },
+                        targets: {
+                            type: 'string',
+                            required: false,
+                            description: 'Comma-separated target names. Defaults to every configured target.',
+                        },
+                        profile: {
+                            type: 'string',
+                            required: false,
+                            default: action === 'verify' ? 'production' : 'development',
+                            description: 'Validation profile (development or production).',
+                        },
+                        'kit-path': {
+                            type: 'string',
+                            required: false,
+                            description: 'Path to the mpgd-kit checkout.',
+                        },
+                    },
+                    run: (ctx) => {
+                        const positionals = readLocalPositionals(ctx.positionals, ['game', 'icons', action]);
+                        const gameRoot = path.resolve(readRequiredPositional(positionals, 0, 'game'));
+                        const env = createTargetCommandEnv({
+                            'targets-file': path.join(gameRoot, 'mpgd.targets.json'),
+                            'kit-path': ctx.values['kit-path'],
+                        });
+                        const targets = readOptionalString(ctx.values.targets) ?? '';
+                        const profile = readOptionalString(ctx.values.profile)
+                            ?? (action === 'verify' ? 'production' : 'development');
+                        runPnpm([`game:icons:${action}`, '--', targets, profile], env);
+                    },
+                }),
+            ])),
+            run: () => {
+                console.log('Use "mpgd game icons generate <game>", verify, or inspect.');
+            },
+        }),
     },
     run: () => {
-        console.log('Use "mpgd game create <directory>".');
+        console.log('Use "mpgd game create <directory>", "mpgd game accept <game>", or "mpgd game icons generate <game>".');
     },
 });
 const defaultLegalDir = 'legal';
 const defaultLegalOutDir = 'artifacts/legal-site';
 const legalPageSlugs = ['privacy', 'support', 'terms'];
 const legalPageFileList = legalPageSlugs.map((slug) => `${slug}.html`).join(', ');
+function acceptGame(input) {
+    if (input.skipTargetBuild && !input.skipTargetSmoke) {
+        throw new Error('Use --skip-target-smoke when --skip-target-build is set.');
+    }
+    const gameRoot = assertGameAcceptanceRoot(input.gameRoot);
+    const gamePackage = readPackageJsonOrUndefined(gameRoot, { strictParse: true });
+    if (gamePackage === undefined) {
+        throw new Error(`Missing game package.json: ${gameRoot}`);
+    }
+    const targetsFile = path.join(gameRoot, 'mpgd.targets.json');
+    if (!existsSync(targetsFile)) {
+        throw new Error(`Missing game target config: ${targetsFile}`);
+    }
+    const kitPath = resolveKitPathForTarget({
+        ...(input.kitPath === undefined ? {} : { 'kit-path': input.kitPath }),
+    });
+    const packageManager = process.platform === 'win32' ? 'pnpm.cmd' : 'pnpm';
+    const steps = [
+        packageScriptAcceptanceStep({
+            id: acceptanceStepIds.check,
+            label: 'Game check',
+            script: 'check',
+            gameRoot,
+            packageManager,
+            scripts: gamePackage.scripts,
+            required: true,
+        }),
+        packageScriptAcceptanceStep({
+            id: acceptanceStepIds.test,
+            label: 'Game tests',
+            script: 'test',
+            gameRoot,
+            packageManager,
+            scripts: gamePackage.scripts,
+            required: false,
+            skipped: input.skipTest,
+        }),
+        packageScriptAcceptanceStep({
+            id: acceptanceStepIds.build,
+            label: 'Game build',
+            script: 'build',
+            gameRoot,
+            packageManager,
+            scripts: gamePackage.scripts,
+            required: true,
+        }),
+        input.skipGraph
+            ? skippedAcceptanceStep(acceptanceStepIds.graph, 'TypeScript graph preflight', 'Disabled by --skip-graph.')
+            : {
+                id: acceptanceStepIds.graph,
+                label: 'TypeScript graph preflight',
+                command: packageManager,
+                args: ['graph:preflight'],
+                cwd: kitPath,
+            },
+        packageScriptAcceptanceStep({
+            id: acceptanceStepIds.playtest,
+            label: 'Automated playtest',
+            script: input.playtestScript,
+            gameRoot,
+            packageManager,
+            scripts: gamePackage.scripts,
+            required: false,
+            skipped: input.skipPlaytest,
+        }),
+        targetMatrixAcceptanceStep({
+            action: 'build-all',
+            id: acceptanceStepIds.targetBuild,
+            label: 'Target build matrix',
+            kitPath,
+            packageManager,
+            targetsFile,
+            targets: input.targets,
+            profile: input.profile,
+            aitVariant: input.aitVariant,
+            ...(input.iosVariant === undefined ? {} : { iosVariant: input.iosVariant }),
+            skipped: input.skipTargetBuild,
+        }),
+        targetMatrixAcceptanceStep({
+            action: 'smoke-all',
+            id: acceptanceStepIds.targetSmoke,
+            label: 'Target smoke matrix',
+            kitPath,
+            packageManager,
+            targetsFile,
+            targets: input.targets,
+            profile: input.profile,
+            aitVariant: input.aitVariant,
+            ...(input.iosVariant === undefined ? {} : { iosVariant: input.iosVariant }),
+            skipped: input.skipTargetSmoke,
+        }),
+    ];
+    const reportDir = path.resolve(gameRoot, input.reportDir ?? 'artifacts/acceptance');
+    const releaseManifestFile = resolveGameAcceptanceReleaseManifestFile(gameRoot);
+    const result = runGameAcceptance({
+        gameRoot,
+        reportDir,
+        ...(input.skipTargetBuild
+            ? {}
+            : { releaseManifestFile }),
+        options: {
+            targets: input.targets,
+            profile: input.profile,
+            aitVariant: input.aitVariant,
+            iosVariant: input.iosVariant ?? null,
+            playtestScript: input.playtestScript,
+            skipTest: input.skipTest,
+            skipGraph: input.skipGraph,
+            skipPlaytest: input.skipPlaytest,
+            skipTargetBuild: input.skipTargetBuild,
+            skipTargetSmoke: input.skipTargetSmoke,
+            timeoutMs: String(input.timeoutMs),
+        },
+        steps,
+        commandTimeoutMs: input.timeoutMs,
+        env: {
+            ...process.env,
+            MPGD_KIT_PATH: kitPath,
+            MPGD_RELEASE_MANIFEST_FILE: releaseManifestFile,
+        },
+    });
+    console.log(`[mpgd:accept] JSON report: ${result.jsonFile}`);
+    console.log(`[mpgd:accept] Markdown report: ${result.markdownFile}`);
+    if (result.report.status === 'failed') {
+        throw new Error(`Game acceptance failed. Report: ${result.markdownFile}`);
+    }
+    console.log('[mpgd:accept] passed');
+}
+function assertGameAcceptanceRoot(gameRoot) {
+    const resolved = path.resolve(gameRoot);
+    if (!existsSync(resolved)) {
+        throw new Error(`Game root does not exist: ${resolved}`);
+    }
+    return realpathSync(resolved);
+}
+function packageScriptAcceptanceStep(input) {
+    if (input.skipped === true) {
+        return skippedAcceptanceStep(input.id, input.label, 'Disabled by command option.');
+    }
+    if (input.scripts?.[input.script] === undefined && !input.required) {
+        return skippedAcceptanceStep(input.id, input.label, `Optional package script "${input.script}" is not configured.`);
+    }
+    return {
+        id: input.id,
+        label: input.label,
+        command: input.packageManager,
+        args: ['run', input.script],
+        cwd: input.gameRoot,
+    };
+}
+function targetMatrixAcceptanceStep(input) {
+    if (input.skipped) {
+        return skippedAcceptanceStep(input.id, input.label, 'Disabled by command option.');
+    }
+    const args = [
+        'mpgd',
+        'target',
+        input.action,
+        '--targets-file',
+        input.targetsFile,
+        '--kit-path',
+        input.kitPath,
+        '--targets',
+        input.targets,
+    ];
+    if (input.action === 'build-all') {
+        args.push('--profile', input.profile, '--ait-variant', input.aitVariant);
+        if (input.iosVariant !== undefined) {
+            args.push('--ios-variant', input.iosVariant);
+        }
+    }
+    return {
+        id: input.id,
+        label: input.label,
+        command: input.packageManager,
+        args,
+        cwd: input.kitPath,
+    };
+}
+function skippedAcceptanceStep(id, label, skipReason) {
+    return { id, label, skipReason };
+}
+function readPositiveInteger(value, label) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        throw new Error(`${label} must be a positive integer.`);
+    }
+    return parsed;
+}
 const legalCommand = defineI18n({
     name: 'legal',
     description: 'Build static legal/support pages for store and release evidence.',
@@ -738,6 +1137,7 @@ function createGameApp(input) {
         '  mpgd target build-all',
         `--targets-file ${path.join(appDir, 'mpgd.targets.json')}`,
         `--targets ${recommendedMatrixTargets}`,
+        '--profile staging',
         '--ait-variant wrapper',
         '--kit-path <path-to-mpgd-kit>',
     ].join(' '));
@@ -1010,7 +1410,7 @@ function readConfiguredPath(value) {
     return normalized === undefined || normalized.length === 0 ? undefined : normalized;
 }
 function readSourceGitSha(gameRoot) {
-    const result = spawnSync('git', ['-C', gameRoot, 'rev-parse', '--short', 'HEAD'], {
+    const result = spawnSync('git', ['-C', gameRoot, 'rev-parse', 'HEAD'], {
         encoding: 'utf8',
         stdio: ['ignore', 'pipe', 'ignore'],
     });
@@ -1088,8 +1488,9 @@ function replaceTargetTokens(value, context) {
 function runTargetCommand(input) {
     const target = normalizeBuildTarget(input.target);
     const env = withTargetVariantEnv(target, input.variant, input.env);
+    const profile = input.profile ?? 'production';
     const args = input.action === 'build'
-        ? ['build:target', target, input.profile ?? 'production']
+        ? ['build:target', target, profile]
         : ['smoke:target', target];
     console.log(`[mpgd] ${input.action} ${target}`);
     runPnpm(args, env);

package/dist/production-target-readiness.d.ts

@@ -0,0 +1,8 @@
+export interface ProductionTargetReadinessInput {
+  readonly target: string;
+  readonly profile: string;
+  readonly targetsFile: string;
+  readonly gameRoot: string;
+  readonly gameServicesUrl?: string;
+}
+export declare function assertProductionTargetReadiness(input: ProductionTargetReadinessInput): void;

package/dist/production-target-readiness.js

@@ -0,0 +1,207 @@
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { isIP } from 'node:net';
+import path from 'node:path';
+const ownerPathByTarget = {
+    ait: 'wrapperApp',
+    android: 'shellApp',
+    ios: 'shellApp',
+};
+export function assertProductionTargetReadiness(input) {
+    if (typeof input.profile !== 'string'
+        || input.profile.length === 0
+        || input.profile.trim() !== input.profile) {
+        throw new Error('Target build profile must be a non-empty string without surrounding whitespace.');
+    }
+    if (input.profile !== 'production') {
+        return;
+    }
+    const ownerPathKey = ownerPathByTarget[input.target];
+    if (ownerPathKey === undefined) {
+        return;
+    }
+    const targetConfig = readTargets(input.targetsFile)[input.target];
+    if (!isRecord(targetConfig)) {
+        throw new Error(`Missing target configuration for ${input.target}.`);
+    }
+    const ownerPath = targetConfig[ownerPathKey];
+    const webDir = targetConfig.webDir;
+    if (typeof ownerPath !== 'string' || ownerPath.length === 0) {
+        throw new Error(`Production target ${input.target} is missing ${ownerPathKey}.`);
+    }
+    if (typeof webDir !== 'string' || webDir.length === 0) {
+        throw new Error(`Production target ${input.target} is missing webDir.`);
+    }
+    const resolvedOwnerPath = path.resolve(path.dirname(input.targetsFile), ownerPath);
+    const resolvedWebDir = path.resolve(path.dirname(input.targetsFile), webDir);
+    const canonicalGameRoot = readCanonicalPath(input.gameRoot, 'game root');
+    const canonicalOwnerPath = readCanonicalPath(resolvedOwnerPath, `${input.target} ${ownerPathKey}`);
+    if (!isDedicatedChildPath(canonicalGameRoot, canonicalOwnerPath)) {
+        throw new Error(`Production target ${input.target} must use a game-owned ${ownerPathKey} inside `
+            + `${canonicalGameRoot}; received ${canonicalOwnerPath}. `
+            + 'Use a non-production profile for kit reference wrapper/shell smoke builds.');
+    }
+    const canonicalWebDir = readCanonicalPathAllowingMissingTail(resolvedWebDir, `${input.target} webDir`);
+    if (!isDedicatedChildPath(canonicalOwnerPath, canonicalWebDir)) {
+        throw new Error(`Production target ${input.target} must keep webDir inside its game-owned `
+            + `${ownerPathKey} ${canonicalOwnerPath}; received ${canonicalWebDir}.`);
+    }
+    if (input.target === 'android' || input.target === 'ios') {
+        const canonicalPlatformDir = readCanonicalPathAllowingMissingTail(path.join(resolvedOwnerPath, input.target), `${input.target} native platform directory`);
+        if (!isDedicatedChildPath(canonicalOwnerPath, canonicalPlatformDir)) {
+            throw new Error(`Production target ${input.target} must keep its native platform directory inside `
+                + `${canonicalOwnerPath}; received ${canonicalPlatformDir}.`);
+        }
+    }
+    assertAuthoritativeGameServicesUrl(input.gameServicesUrl, input.target);
+}
+function readTargets(targetsFile) {
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(targetsFile, 'utf8'));
+    }
+    catch (error) {
+        throw new Error(`Failed to read prepared targets file ${targetsFile}: ${formatError(error)}`);
+    }
+    if (!isRecord(parsed) || !isRecord(parsed.targets)) {
+        throw new Error(`Prepared targets file ${targetsFile} must contain a targets object.`);
+    }
+    return parsed.targets;
+}
+// Equality is rejected: a wrapper or shell must be a dedicated child of the game root.
+function isDedicatedChildPath(parent, candidate) {
+    const relative = path.relative(parent, candidate);
+    return relative.length > 0
+        && relative !== '..'
+        && !relative.startsWith(`..${path.sep}`)
+        && !path.isAbsolute(relative);
+}
+function readCanonicalPath(candidate, label) {
+    try {
+        return realpathSync(candidate);
+    }
+    catch (error) {
+        throw new Error(`Production ${label} must exist: ${candidate} (${formatError(error)})`);
+    }
+}
+function readCanonicalPathAllowingMissingTail(candidate, label) {
+    let existingPath = candidate;
+    const missingSegments = [];
+    while (!existsSync(existingPath)) {
+        const parent = path.dirname(existingPath);
+        if (parent === existingPath) {
+            throw new Error(`Production ${label} has no existing ancestor: ${candidate}`);
+        }
+        missingSegments.unshift(path.basename(existingPath));
+        existingPath = parent;
+    }
+    return path.join(readCanonicalPath(existingPath, label), ...missingSegments);
+}
+function assertAuthoritativeGameServicesUrl(value, target) {
+    if (value === undefined || value.length === 0) {
+        throw new Error(`Production target ${target} requires VITE_MPGD_GAME_SERVICES_URL for an `
+            + 'authoritative remote backend.');
+    }
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new Error(`Production target ${target} has an invalid game-services URL.`);
+    }
+    if (url.protocol !== 'https:'
+        || url.username.length > 0
+        || url.password.length > 0
+        || isNonPublicServiceHostname(url.hostname)) {
+        throw new Error(`Production target ${target} requires a public HTTPS game-services URL `
+            + 'without embedded credentials.');
+    }
+}
+function isNonPublicServiceHostname(hostname) {
+    const normalized = hostname.toLowerCase().replace(/^\[|\]$/g, '').replace(/\.$/u, '');
+    if (normalized === 'localhost'
+        || normalized.endsWith('.localhost')
+        || normalized.endsWith('.local')) {
+        return true;
+    }
+    const ipVersion = isIP(normalized);
+    if (ipVersion === 4) {
+        return isNonPublicIpv4(normalized);
+    }
+    if (ipVersion === 6) {
+        return isNonPublicIpv6(normalized);
+    }
+    return false;
+}
+function isNonPublicIpv4(address) {
+    const [first = 0, second = 0, third = 0] = address.split('.').map(Number);
+    return first === 0
+        || first === 10
+        || first === 127
+        || (first === 100 && second >= 64 && second <= 127)
+        || (first === 169 && second === 254)
+        || (first === 172 && second >= 16 && second <= 31)
+        || (first === 192 && second === 0 && third === 0)
+        || (first === 192 && second === 0 && third === 2)
+        || (first === 192 && second === 168)
+        || (first === 198 && (second === 18 || second === 19))
+        || (first === 198 && second === 51 && third === 100)
+        || (first === 203 && second === 0 && third === 113)
+        || first >= 224;
+}
+function isNonPublicIpv6(address) {
+    const words = expandIpv6(address);
+    if (words === undefined) {
+        return true;
+    }
+    if (words.slice(0, 7).every((word) => word === 0)) {
+        return true;
+    }
+    if (words.slice(0, 5).every((word) => word === 0) && words[5] === 0xffff) {
+        return isNonPublicIpv4(`${(words[6] ?? 0) >> 8}.${(words[6] ?? 0) & 0xff}.`
+            + `${(words[7] ?? 0) >> 8}.${(words[7] ?? 0) & 0xff}`);
+    }
+    if (words.slice(0, 6).every((word) => word === 0)) {
+        return isNonPublicIpv4(`${(words[6] ?? 0) >> 8}.${(words[6] ?? 0) & 0xff}.`
+            + `${(words[7] ?? 0) >> 8}.${(words[7] ?? 0) & 0xff}`);
+    }
+    const first = words[0] ?? 0;
+    return (first & 0xfe00) === 0xfc00
+        || (first & 0xffc0) === 0xfe80
+        || (first & 0xff00) === 0xff00
+        || (first === 0x2001 && words[1] === 0x0db8);
+}
+function expandIpv6(address) {
+    const sections = address.split('::');
+    if (sections.length > 2) {
+        return undefined;
+    }
+    const head = ipv6Words(sections[0] ?? '');
+    const tail = ipv6Words(sections[1] ?? '');
+    if (head === undefined || tail === undefined) {
+        return undefined;
+    }
+    const omitted = 8 - head.length - tail.length;
+    if ((sections.length === 1 && omitted !== 0) || (sections.length === 2 && omitted < 1)) {
+        return undefined;
+    }
+    return [...head, ...Array.from({ length: omitted }, () => 0), ...tail];
+}
+function ipv6Words(section) {
+    if (section.length === 0) {
+        return [];
+    }
+    const words = [];
+    for (const segment of section.split(':')) {
+        if (!/^[0-9a-f]{1,4}$/u.test(segment)) {
+            return undefined;
+        }
+        words.push(Number.parseInt(segment, 16));
+    }
+    return words;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function formatError(error) {
+    return error instanceof Error ? error.message : String(error);
+}