@playcraft/build 0.0.44 → 0.0.46

package/dist/validation/source-scanner.js

@@ -0,0 +1,271 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { getRulesForStage } from './profiles.js';
+const SOURCE_EXTENSIONS = new Set(['.js', '.jsx', '.ts', '.tsx', '.html', '.css']);
+const IGNORED_DIRS = new Set([
+    '.git',
+    '.playcraft-temp',
+    'coverage',
+    'dist',
+    'build',
+    'node_modules',
+    'out',
+]);
+const COMMON_SOURCE_PATTERNS = [
+    {
+        ruleId: 'common.redirect.location.forbidden',
+        pattern: /\blocation\.(?:href|assign|replace)\b/g,
+        message: 'Source contains a direct location redirect.',
+        recommendation: 'Move store jumps behind the channel CTA API and an explicit user action.',
+        severity: 'warning',
+        confidence: 'medium',
+    },
+    {
+        ruleId: 'common.redirect.window-open.review',
+        pattern: /\bwindow\.open\s*\(/g,
+        message: 'Source contains window.open().',
+        recommendation: 'Confirm the call is only triggered by an explicit CTA click.',
+        severity: 'warning',
+        confidence: 'medium',
+    },
+    {
+        ruleId: 'common.network.fetch.review',
+        pattern: /\b(?:fetch|XMLHttpRequest|WebSocket|EventSource)\b/g,
+        message: 'Source contains a runtime network API.',
+        recommendation: 'Remove runtime network dependency unless the channel allows analytics-only calls.',
+        severity: 'warning',
+        confidence: 'medium',
+    },
+    {
+        ruleId: 'common.audio.autoplay.review',
+        pattern: /<audio\b[^>]*\bautoplay\b|new\s+Audio\s*\([^)]*\)\.play\s*\(|AudioContext\s*\([^)]*\).*?resume\s*\(/gs,
+        message: 'Source contains a possible audio autoplay pattern.',
+        recommendation: 'Start audio only after user interaction and stop it when the ad is not viewable.',
+        severity: 'warning',
+        confidence: 'low',
+    },
+    {
+        ruleId: 'common.layout.fixed-size.review',
+        pattern: /\b(?:canvas|body|#?app|#?root)[^{]{0,80}\{[^}]*\b(?:width|height)\s*:\s*\d{3,4}px/gs,
+        message: 'Source contains a possible fixed-size layout.',
+        recommendation: 'Use responsive sizing so the playable can adapt to mobile viewports.',
+        severity: 'warning',
+        confidence: 'low',
+    },
+];
+const CHANNEL_SOURCE_PATTERNS = {
+    unity: [
+        {
+            ruleId: 'unity.mraid.viewable-change.required',
+            pattern: /viewableChange/g,
+            message: 'Unity requires waiting for MRAID viewableChange before starting playable content.',
+            recommendation: 'Add a viewableChange listener and start gameplay only after the ad is viewable.',
+            severity: 'error',
+            confidence: 'high',
+        },
+    ],
+    mintegral: [
+        {
+            ruleId: 'mintegral.lifecycle.sdk-finish.required',
+            pattern: /\bsdk\.finish\s*\(/g,
+            message: 'Mintegral requires sdk.finish() after gameplay ends.',
+            recommendation: 'Call sdk.finish() when the win or end state is reached.',
+            severity: 'error',
+            confidence: 'high',
+        },
+    ],
+    bigo: [
+        {
+            ruleId: 'bigo.lifecycle.game-end.required',
+            pattern: /window\.BGY_MRAID\.gameEnd\s*\(/g,
+            message: 'BIGO requires window.BGY_MRAID.gameEnd() when gameplay ends.',
+            recommendation: 'Call window.BGY_MRAID.gameEnd() at the end of gameplay.',
+            severity: 'error',
+            confidence: 'high',
+        },
+    ],
+};
+export async function scanSourceForCompliance(context) {
+    const sourceFiles = await collectSourceFiles(context.projectRoot, context.sourceGlobs);
+    return scanSourceFilesForChannel(context, sourceFiles, true);
+}
+export async function scanSourceForChannels(context, channels) {
+    const sourceFiles = await collectSourceFiles(context.projectRoot, context.sourceGlobs);
+    const results = [];
+    for (const filePath of sourceFiles) {
+        let content;
+        try {
+            content = await fs.readFile(filePath, 'utf-8');
+        }
+        catch {
+            continue;
+        }
+        for (const pattern of COMMON_SOURCE_PATTERNS) {
+            results.push(...evaluateSourcePatternForChannel(context, 'common', filePath, content, pattern));
+        }
+    }
+    for (const channel of unique(channels)) {
+        results.push(...await scanSourceFilesForChannel({ ...context, channel }, sourceFiles, false));
+    }
+    return results;
+}
+async function scanSourceFilesForChannel(context, sourceFiles, includeCommonPatterns) {
+    const results = [];
+    const requiredPatterns = CHANNEL_SOURCE_PATTERNS[context.channel] ?? [];
+    const matchedRequiredRuleIds = new Set();
+    for (const filePath of sourceFiles) {
+        let content;
+        try {
+            content = await fs.readFile(filePath, 'utf-8');
+        }
+        catch {
+            continue;
+        }
+        if (includeCommonPatterns) {
+            for (const pattern of COMMON_SOURCE_PATTERNS) {
+                results.push(...evaluateSourcePattern(context, filePath, content, pattern, false));
+            }
+        }
+        for (const pattern of requiredPatterns) {
+            if (matchedRequiredRuleIds.has(pattern.ruleId)) {
+                continue;
+            }
+            const match = content.match(pattern.pattern);
+            if (match) {
+                matchedRequiredRuleIds.add(pattern.ruleId);
+                results.push({
+                    ruleId: pattern.ruleId,
+                    channel: context.channel,
+                    stage: 'prebuild-source',
+                    severity: pattern.severity,
+                    status: 'pass',
+                    message: `${pattern.message}: passed`,
+                    recommendation: pattern.recommendation,
+                    file: filePath,
+                    line: lineOfIndex(content, content.search(pattern.pattern)),
+                    evidence: trimEvidence(match[0]),
+                    owner: ownerForContext(context),
+                    confidence: pattern.confidence,
+                });
+            }
+        }
+    }
+    results.push(...missingRequiredPatternResults(context, matchedRequiredRuleIds));
+    return results;
+}
+function evaluateSourcePatternForChannel(context, channel, filePath, content, sourcePattern) {
+    const matches = Array.from(content.matchAll(sourcePattern.pattern));
+    return matches.slice(0, 10).map((match) => ({
+        ruleId: sourcePattern.ruleId,
+        channel,
+        stage: 'prebuild-source',
+        severity: sourcePattern.severity,
+        status: sourcePattern.severity === 'error' ? 'fail' : 'warning',
+        message: sourcePattern.message,
+        recommendation: sourcePattern.recommendation,
+        file: filePath,
+        line: lineOfIndex(content, match.index ?? 0),
+        evidence: trimEvidence(match[0]),
+        owner: ownerForContext(context),
+        confidence: sourcePattern.confidence,
+    }));
+}
+async function collectSourceFiles(projectRoot, explicitGlobs) {
+    if (explicitGlobs && explicitGlobs.length > 0) {
+        const files = [];
+        for (const item of explicitGlobs) {
+            const fullPath = path.isAbsolute(item) ? item : path.join(projectRoot, item);
+            try {
+                const stat = await fs.stat(fullPath);
+                if (stat.isFile() && SOURCE_EXTENSIONS.has(path.extname(fullPath).toLowerCase())) {
+                    files.push(fullPath);
+                }
+                else if (stat.isDirectory()) {
+                    files.push(...await walkSourceFiles(fullPath));
+                }
+            }
+            catch {
+                // Ignore missing explicit entries; the report stays focused on detected evidence.
+            }
+        }
+        return unique(files);
+    }
+    return walkSourceFiles(projectRoot);
+}
+async function walkSourceFiles(dir) {
+    const files = [];
+    let entries;
+    try {
+        entries = await fs.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return files;
+    }
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (!IGNORED_DIRS.has(entry.name)) {
+                files.push(...await walkSourceFiles(fullPath));
+            }
+            continue;
+        }
+        if (entry.isFile() && SOURCE_EXTENSIONS.has(path.extname(entry.name).toLowerCase())) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+function evaluateSourcePattern(context, filePath, content, sourcePattern, requiredPresence) {
+    const matches = Array.from(content.matchAll(sourcePattern.pattern));
+    if (requiredPresence) {
+        return [];
+    }
+    return matches.slice(0, 10).map((match) => ({
+        ruleId: sourcePattern.ruleId,
+        channel: context.channel,
+        stage: 'prebuild-source',
+        severity: sourcePattern.severity,
+        status: sourcePattern.severity === 'error' ? 'fail' : 'warning',
+        message: sourcePattern.message,
+        recommendation: sourcePattern.recommendation,
+        file: filePath,
+        line: lineOfIndex(content, match.index ?? 0),
+        evidence: trimEvidence(match[0]),
+        owner: ownerForContext(context),
+        confidence: sourcePattern.confidence,
+    }));
+}
+function missingRequiredPatternResults(context, matchedRequiredRuleIds) {
+    const channelPatterns = CHANNEL_SOURCE_PATTERNS[context.channel] ?? [];
+    const results = [];
+    const sourceRuleIds = new Set(getRulesForStage(context.channel, 'prebuild-source').map((rule) => rule.id));
+    for (const pattern of channelPatterns) {
+        if (matchedRequiredRuleIds.has(pattern.ruleId) || !sourceRuleIds.has(pattern.ruleId)) {
+            continue;
+        }
+        results.push({
+            ruleId: pattern.ruleId,
+            channel: context.channel,
+            stage: 'prebuild-source',
+            severity: pattern.severity,
+            status: pattern.severity === 'error' ? 'fail' : 'warning',
+            message: pattern.message,
+            recommendation: pattern.recommendation,
+            owner: ownerForContext(context),
+            confidence: pattern.confidence,
+        });
+    }
+    return results;
+}
+function ownerForContext(context) {
+    return context.buildChain === 'devkit' ? 'devkit' : 'playcraft-build';
+}
+function lineOfIndex(content, index) {
+    return content.slice(0, index).split(/\r?\n/).length;
+}
+function trimEvidence(value) {
+    return value.replace(/\s+/g, ' ').trim().slice(0, 200);
+}
+function unique(items) {
+    return Array.from(new Set(items));
+}

package/dist/validation/types.d.ts

@@ -0,0 +1,112 @@
+import type { BuildTool, EngineType, OutputFormat, Platform } from '../types.js';
+export type ValidationStage = 'prebuild-source' | 'base-output' | 'html-artifact' | 'delivery-package' | 'runtime-manual' | 'external-validator';
+export type RuleSeverity = 'error' | 'warning' | 'info';
+export type RuleStatus = 'pass' | 'fail' | 'warning' | 'manual' | 'external' | 'not-applicable';
+export type RuleConfidence = 'high' | 'medium' | 'low';
+export type RuleOwner = 'playcraft-build' | 'playcraft-delivery' | 'devkit' | 'manual' | 'external';
+export type DeliveryMode = 'single-html' | 'zip' | 'html-backed-zip' | 'fragment-assets' | 'mixed';
+export type BuildChain = 'generic' | 'devkit' | 'playcanvas-native';
+export type EvidenceType = 'file' | 'pattern' | 'package' | 'runtime' | 'external';
+export type AutoCheck = {
+    kind: 'max-size';
+    maxBytes: number;
+} | {
+    kind: 'external-resources';
+    allowedPatterns?: string[];
+} | {
+    kind: 'required-pattern';
+    pattern: string;
+    flags?: string;
+    evidence?: string;
+} | {
+    kind: 'forbidden-pattern';
+    pattern: string;
+    flags?: string;
+    evidence?: string;
+} | {
+    kind: 'single-html';
+};
+export interface ValidationRule {
+    id: string;
+    title: string;
+    channel: Platform | 'common';
+    stage: ValidationStage;
+    severity: RuleSeverity;
+    owner: RuleOwner;
+    detectable: boolean;
+    confidence: RuleConfidence;
+    description: string;
+    recommendation: string;
+    evidenceType: EvidenceType;
+    source: string;
+    check?: AutoCheck;
+}
+export interface ChannelRuleProfile {
+    channel: Platform;
+    displayName: string;
+    defaultStages: ValidationStage[];
+    optionalStages: ValidationStage[];
+    deliveryMode: DeliveryMode;
+    internalBuildFormat: OutputFormat | 'delegated';
+    deliveryPackageFormat?: OutputFormat | 'fragment-assets' | 'mixed';
+    devkitOwned?: boolean;
+    rules: ValidationRule[];
+}
+export interface ValidationContext {
+    projectRoot: string;
+    channel: Platform;
+    engine: EngineType | 'unknown';
+    buildTool?: BuildTool;
+    buildChain: BuildChain;
+    htmlPath?: string;
+    packagePath?: string;
+    outputDir?: string;
+    sourceGlobs?: string[];
+    metadata?: Record<string, unknown>;
+}
+export interface ManualChecklistItem {
+    ruleId: string;
+    channel: Platform | 'common';
+    stage: ValidationStage;
+    message: string;
+    recommendation: string;
+    owner: RuleOwner;
+}
+export interface ExternalChecklistItem {
+    ruleId: string;
+    channel: Platform | 'common';
+    stage: ValidationStage;
+    message: string;
+    recommendation: string;
+    owner: RuleOwner;
+}
+export interface ValidationResult {
+    ruleId: string;
+    channel: Platform | 'common';
+    stage: ValidationStage;
+    severity: RuleSeverity;
+    status: RuleStatus;
+    message: string;
+    recommendation: string;
+    file?: string;
+    line?: number;
+    evidence?: string;
+    owner: RuleOwner;
+    confidence: RuleConfidence;
+}
+export interface ValidationSummary {
+    status: 'pass' | 'failed' | 'warning' | 'manual-required';
+    errorCount: number;
+    warningCount: number;
+    manualCount: number;
+    externalCount: number;
+}
+export interface ValidationReport {
+    version: string;
+    channel: Platform;
+    buildChain: BuildChain;
+    summary: ValidationSummary;
+    results: ValidationResult[];
+    manualChecklist: ManualChecklistItem[];
+    externalChecklist: ExternalChecklistItem[];
+}

package/dist/validation/validation-runner.d.ts

@@ -0,0 +1,5 @@
+import type { Platform } from '../types.js';
+import type { ValidationContext, ValidationReport, ValidationStage } from './types.js';
+export declare const VALIDATION_REPORT_VERSION = "0.1.0";
+export declare function runPlayableValidation(context: ValidationContext, stages?: ValidationStage[]): Promise<ValidationReport>;
+export declare function runPlayableSourceValidationForChannels(context: Omit<ValidationContext, 'channel'>, channels: Platform[]): Promise<ValidationReport>;

package/dist/validation/validation-runner.js

@@ -0,0 +1,96 @@
+import { getChannelRuleProfile } from './profiles.js';
+import { validateHtmlArtifact } from './html-validator.js';
+import { validateDeliveryPackage } from './package-validator.js';
+import { scanSourceForChannels, scanSourceForCompliance } from './source-scanner.js';
+export const VALIDATION_REPORT_VERSION = '0.1.0';
+export async function runPlayableValidation(context, stages) {
+    const profile = getChannelRuleProfile(context.channel);
+    const defaultStages = [...profile.defaultStages];
+    if (context.packagePath && profile.optionalStages.includes('delivery-package')) {
+        defaultStages.push('delivery-package');
+    }
+    const enabledStages = new Set(stages ?? defaultStages);
+    const results = [];
+    if (enabledStages.has('prebuild-source')) {
+        results.push(...await scanSourceForCompliance(context));
+    }
+    if (enabledStages.has('html-artifact')) {
+        results.push(...await validateHtmlArtifact(context, profile));
+    }
+    if (enabledStages.has('delivery-package')) {
+        results.push(...await validateDeliveryPackage(context, profile));
+    }
+    const manualChecklist = buildManualChecklist(profile.rules, enabledStages);
+    const externalChecklist = buildExternalChecklist(profile.rules, enabledStages);
+    return {
+        version: VALIDATION_REPORT_VERSION,
+        channel: context.channel,
+        buildChain: context.buildChain,
+        summary: summarize(results, manualChecklist, externalChecklist),
+        results,
+        manualChecklist,
+        externalChecklist,
+    };
+}
+export async function runPlayableSourceValidationForChannels(context, channels) {
+    const uniqueChannels = Array.from(new Set(channels));
+    const results = await scanSourceForChannels(context, uniqueChannels);
+    return {
+        version: VALIDATION_REPORT_VERSION,
+        channel: uniqueChannels[0] ?? 'playcraft',
+        buildChain: context.buildChain,
+        summary: summarize(results, [], []),
+        results,
+        manualChecklist: [],
+        externalChecklist: [],
+    };
+}
+function buildManualChecklist(rules, enabledStages) {
+    return rules
+        .filter((rule) => rule.owner === 'manual')
+        .filter((rule) => enabledStages.has(rule.stage) || rule.stage === 'runtime-manual')
+        .map((rule) => ({
+        ruleId: rule.id,
+        channel: rule.channel,
+        stage: rule.stage,
+        message: rule.title,
+        recommendation: rule.recommendation,
+        owner: rule.owner,
+    }));
+}
+function buildExternalChecklist(rules, enabledStages) {
+    return rules
+        .filter((rule) => rule.owner === 'external')
+        .filter((rule) => enabledStages.has(rule.stage) || rule.stage === 'external-validator')
+        .map((rule) => ({
+        ruleId: rule.id,
+        channel: rule.channel,
+        stage: rule.stage,
+        message: rule.title,
+        recommendation: rule.recommendation,
+        owner: rule.owner,
+    }));
+}
+function summarize(results, manualChecklist, externalChecklist) {
+    const errorCount = results.filter((result) => result.status === 'fail').length;
+    const warningCount = results.filter((result) => result.status === 'warning').length;
+    const manualCount = manualChecklist.length;
+    const externalCount = externalChecklist.length;
+    let status = 'pass';
+    if (errorCount > 0) {
+        status = 'failed';
+    }
+    else if (warningCount > 0) {
+        status = 'warning';
+    }
+    else if (manualCount > 0 || externalCount > 0) {
+        status = 'manual-required';
+    }
+    return {
+        status,
+        errorCount,
+        warningCount,
+        manualCount,
+        externalCount,
+    };
+}

package/dist/validation/zip-reader.d.ts

@@ -0,0 +1,17 @@
+export interface ZipEntryInfo {
+    path: string;
+    compressedSize: number;
+    uncompressedSize: number;
+    compressionMethod: number;
+    isDirectory: boolean;
+}
+export declare class SimpleZipReader {
+    private readonly buffer;
+    private entriesCache?;
+    constructor(buffer: Buffer);
+    listEntries(): ZipEntryInfo[];
+    readEntryText(entryPath: string): string | null;
+    private readCentralDirectory;
+    private readEntryData;
+    private findEndOfCentralDirectory;
+}

package/dist/validation/zip-reader.js

@@ -0,0 +1,84 @@
+import { inflateRawSync } from 'zlib';
+export class SimpleZipReader {
+    constructor(buffer) {
+        this.buffer = buffer;
+    }
+    listEntries() {
+        return this.readCentralDirectory().map(({ localHeaderOffset: _offset, ...entry }) => entry);
+    }
+    readEntryText(entryPath) {
+        const entry = this.readCentralDirectory().find((item) => item.path === entryPath);
+        if (!entry || entry.isDirectory)
+            return null;
+        const data = this.readEntryData(entry);
+        return data.toString('utf-8');
+    }
+    readCentralDirectory() {
+        if (this.entriesCache)
+            return this.entriesCache;
+        const eocdOffset = this.findEndOfCentralDirectory();
+        if (eocdOffset < 0) {
+            throw new Error('Invalid ZIP: end of central directory not found');
+        }
+        const totalEntries = this.buffer.readUInt16LE(eocdOffset + 10);
+        const centralDirectoryOffset = this.buffer.readUInt32LE(eocdOffset + 16);
+        const entries = [];
+        let offset = centralDirectoryOffset;
+        for (let i = 0; i < totalEntries; i++) {
+            const signature = this.buffer.readUInt32LE(offset);
+            if (signature !== 0x02014b50) {
+                throw new Error(`Invalid ZIP: bad central directory signature at ${offset}`);
+            }
+            const compressionMethod = this.buffer.readUInt16LE(offset + 10);
+            const compressedSize = this.buffer.readUInt32LE(offset + 20);
+            const uncompressedSize = this.buffer.readUInt32LE(offset + 24);
+            const fileNameLength = this.buffer.readUInt16LE(offset + 28);
+            const extraLength = this.buffer.readUInt16LE(offset + 30);
+            const commentLength = this.buffer.readUInt16LE(offset + 32);
+            const localHeaderOffset = this.buffer.readUInt32LE(offset + 42);
+            const fileNameStart = offset + 46;
+            const entryPath = this.buffer
+                .subarray(fileNameStart, fileNameStart + fileNameLength)
+                .toString('utf-8')
+                .replace(/\\/g, '/');
+            entries.push({
+                path: entryPath,
+                compressedSize,
+                uncompressedSize,
+                compressionMethod,
+                localHeaderOffset,
+                isDirectory: entryPath.endsWith('/'),
+            });
+            offset = fileNameStart + fileNameLength + extraLength + commentLength;
+        }
+        this.entriesCache = entries;
+        return entries;
+    }
+    readEntryData(entry) {
+        const offset = entry.localHeaderOffset;
+        const signature = this.buffer.readUInt32LE(offset);
+        if (signature !== 0x04034b50) {
+            throw new Error(`Invalid ZIP: bad local header signature at ${offset}`);
+        }
+        const fileNameLength = this.buffer.readUInt16LE(offset + 26);
+        const extraLength = this.buffer.readUInt16LE(offset + 28);
+        const dataStart = offset + 30 + fileNameLength + extraLength;
+        const compressed = this.buffer.subarray(dataStart, dataStart + entry.compressedSize);
+        if (entry.compressionMethod === 0) {
+            return Buffer.from(compressed);
+        }
+        if (entry.compressionMethod === 8) {
+            return inflateRawSync(compressed);
+        }
+        throw new Error(`Unsupported ZIP compression method: ${entry.compressionMethod}`);
+    }
+    findEndOfCentralDirectory() {
+        const minOffset = Math.max(0, this.buffer.length - 0xffff - 22);
+        for (let offset = this.buffer.length - 22; offset >= minOffset; offset--) {
+            if (this.buffer.readUInt32LE(offset) === 0x06054b50) {
+                return offset;
+            }
+        }
+        return -1;
+    }
+}

package/dist/vite/platform-configs.js

@@ -67,7 +67,7 @@ export const PLATFORM_CONFIGS = {
     },
     snapchat: {
         sizeLimit: 5 * 1024 * 1024, // 5MB
-        outputFormat: 'zip',
+        outputFormat: 'html',
         minifyCSS: true,
         minifyJS: true,
         compressImages: false, // 禁用图片压缩，原图输出效果更好
@@ -185,7 +185,7 @@ export const PLATFORM_CONFIGS = {
     },
     tiktok: {
         sizeLimit: 5 * 1024 * 1024, // 5MB
-        outputFormat: 'zip',
+        outputFormat: 'html',
         minifyCSS: true,
         minifyJS: true,
         compressImages: false, // 禁用图片压缩，原图输出效果更好
@@ -243,7 +243,7 @@ export const PLATFORM_CONFIGS = {
     },
     liftoff: {
         sizeLimit: 5 * 1024 * 1024, // 5MB
-        outputFormat: 'zip',
+        outputFormat: 'html',
         minifyCSS: true,
         minifyJS: true,
         compressImages: false, // 禁用图片压缩，原图输出效果更好
@@ -301,7 +301,7 @@ export const PLATFORM_CONFIGS = {
     },
     bigo: {
         sizeLimit: 5 * 1024 * 1024, // 5MB
-        outputFormat: 'zip',
+        outputFormat: 'html',
         minifyCSS: true,
         minifyJS: true,
         compressImages: false, // 禁用图片压缩，原图输出效果更好
@@ -329,7 +329,7 @@ export const PLATFORM_CONFIGS = {
     },
     inmobi: {
         sizeLimit: 5 * 1024 * 1024, // 5MB
-        outputFormat: 'zip',
+        outputFormat: 'html',
         minifyCSS: true,
         minifyJS: true,
         compressImages: false, // 禁用图片压缩，原图输出效果更好
@@ -416,8 +416,8 @@ export const PLATFORM_CONFIGS = {
         },
     },
     mintegral: {
-        sizeLimit: 5 * 1024 * 1024, // 5MB (ZIP)
-        outputFormat: 'zip',
+        sizeLimit: 5 * 1024 * 1024, // 5MB
+        outputFormat: 'html',
         minifyCSS: true,
         minifyJS: true,
         compressImages: false, // 禁用图片压缩，原图输出效果更好

package/dist/vite-builder.d.ts

@@ -82,5 +82,6 @@ export declare class ViteBuilder {
     /**
      * 格式化字节数
      */
+    private runComplianceValidation;
     private formatBytes;
 }