@playcraft/build 0.0.44 → 0.0.46

package/dist/validation/package-validator.js

@@ -0,0 +1,198 @@
+import fs from 'fs/promises';
+import fsSync from 'fs';
+import path from 'path';
+import { getChannelRuleProfile } from './profiles.js';
+import { SimpleZipReader } from './zip-reader.js';
+const FIVE_MB = 5 * 1024 * 1024;
+export async function validateDeliveryPackage(context, profile = getChannelRuleProfile(context.channel)) {
+    if (!context.packagePath) {
+        return [{
+                ruleId: `${context.channel}.package.path.required`,
+                channel: context.channel,
+                stage: 'delivery-package',
+                severity: 'error',
+                status: 'fail',
+                message: 'Delivery package path is missing.',
+                recommendation: 'Pass the ZIP file or delivery directory path to the validation context.',
+                owner: 'playcraft-delivery',
+                confidence: 'high',
+            }];
+    }
+    let inventory;
+    try {
+        inventory = await readPackageInventory(context.packagePath);
+    }
+    catch (error) {
+        return [{
+                ruleId: `${context.channel}.package.readable.required`,
+                channel: context.channel,
+                stage: 'delivery-package',
+                severity: 'error',
+                status: 'fail',
+                message: `Delivery package is not readable: ${context.packagePath}`,
+                recommendation: 'Verify the generated ZIP or delivery directory exists and is readable.',
+                file: context.packagePath,
+                evidence: error instanceof Error ? error.message : String(error),
+                owner: 'playcraft-delivery',
+                confidence: 'high',
+            }];
+    }
+    const results = [
+        boolResult(context.channel, 'package.size.max-5mb', inventory.size <= FIVE_MB, 'Delivery package should be smaller than 5 MB.', 'Reduce artifact size or compression output.', inventory.packagePath, `actual=${inventory.size}, limit=${FIVE_MB}`),
+    ];
+    if (profile.deliveryPackageFormat === 'zip' || profile.deliveryMode === 'zip' || profile.deliveryMode === 'html-backed-zip') {
+        results.push(...validateZipLikePackage(context.channel, inventory));
+    }
+    switch (context.channel) {
+        case 'google':
+            results.push(boolResult('google', 'package.file-count.max-512', fileEntries(inventory).length <= 512, 'Google ZIP should contain no more than 512 files.', 'Reduce generated files or inline assets.', inventory.packagePath, `files=${fileEntries(inventory).length}`));
+            break;
+        case 'tiktok':
+            results.push(...validateJsonField(context.channel, inventory, 'config.json', 'playable_orientation', [0, 1, 2]));
+            break;
+        case 'bigo':
+            results.push(...validateJsonField(context.channel, inventory, 'config.json', 'orientation', [0, 1, 2]));
+            break;
+        case 'snapchat':
+            results.push(...validateJsonField(context.channel, inventory, 'config.json', 'orientation', [1]));
+            break;
+        case 'adikteev':
+            results.push(...validateAdikteevPackage(inventory));
+            break;
+    }
+    return results;
+}
+async function readPackageInventory(packagePath) {
+    const stat = await fs.stat(packagePath);
+    if (stat.isDirectory()) {
+        const entries = await readDirectoryEntries(packagePath);
+        return {
+            packagePath,
+            entries,
+            readText: (entryPath) => readTextFromDirectorySyncUnsupported(packagePath, entryPath),
+            size: await calculateDirectorySize(packagePath),
+        };
+    }
+    const buffer = await fs.readFile(packagePath);
+    const zip = new SimpleZipReader(buffer);
+    return {
+        packagePath,
+        entries: zip.listEntries(),
+        readText: (entryPath) => zip.readEntryText(entryPath),
+        size: buffer.length,
+    };
+}
+async function readDirectoryEntries(dir) {
+    const entries = [];
+    const walk = async (current) => {
+        const dirEntries = await fs.readdir(current, { withFileTypes: true });
+        for (const entry of dirEntries) {
+            const fullPath = path.join(current, entry.name);
+            const relative = path.relative(dir, fullPath).replace(/\\/g, '/');
+            if (entry.isDirectory()) {
+                entries.push({
+                    path: `${relative}/`,
+                    compressedSize: 0,
+                    uncompressedSize: 0,
+                    compressionMethod: 0,
+                    isDirectory: true,
+                });
+                await walk(fullPath);
+            }
+            else {
+                const stat = await fs.stat(fullPath);
+                entries.push({
+                    path: relative,
+                    compressedSize: stat.size,
+                    uncompressedSize: stat.size,
+                    compressionMethod: 0,
+                    isDirectory: false,
+                });
+            }
+        }
+    };
+    await walk(dir);
+    return entries;
+}
+function readTextFromDirectorySyncUnsupported(_packagePath, _entryPath) {
+    const filePath = path.join(_packagePath, _entryPath);
+    try {
+        return fsSync.readFileSync(filePath, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+async function calculateDirectorySize(dir) {
+    let total = 0;
+    const walk = async (current) => {
+        const entries = await fs.readdir(current, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                await walk(fullPath);
+            }
+            else {
+                total += (await fs.stat(fullPath)).size;
+            }
+        }
+    };
+    await walk(dir);
+    return total;
+}
+function validateZipLikePackage(channel, inventory) {
+    const paths = new Set(inventory.entries.map((entry) => entry.path));
+    return [
+        boolResult(channel, 'package.index-html.root-required', paths.has('index.html'), 'Delivery package should contain root index.html.', 'Place the playable entry file at the root of the delivery package.', inventory.packagePath),
+    ];
+}
+function validateJsonField(channel, inventory, entryPath, fieldName, allowedValues) {
+    const paths = new Set(inventory.entries.map((entry) => entry.path));
+    const results = [
+        boolResult(channel, `package.${entryPath}.root-required`, paths.has(entryPath), `Delivery package should contain root ${entryPath}.`, `Generate ${entryPath} at the package root.`, inventory.packagePath),
+    ];
+    if (!paths.has(entryPath)) {
+        return results;
+    }
+    try {
+        const raw = inventory.readText(entryPath);
+        if (!raw) {
+            return results;
+        }
+        const json = JSON.parse(raw);
+        results.push(boolResult(channel, `package.${fieldName}.valid`, allowedValues.includes(json[fieldName]), `${entryPath} should contain valid ${fieldName}.`, `Set ${fieldName} to one of: ${allowedValues.join(', ')}.`, inventory.packagePath, `${fieldName}=${JSON.stringify(json[fieldName])}`));
+    }
+    catch (error) {
+        results.push(boolResult(channel, `package.${entryPath}.json-valid`, false, `${entryPath} should be valid JSON.`, `Fix ${entryPath} so it can be parsed as JSON.`, inventory.packagePath, error instanceof Error ? error.message : String(error)));
+    }
+    return results;
+}
+function validateAdikteevPackage(inventory) {
+    const files = fileEntries(inventory);
+    const hasHtml = files.some((entry) => entry.path.endsWith('.html') || entry.path.endsWith('.htm'));
+    const hasJs = files.some((entry) => entry.path.endsWith('.js'));
+    const hasCss = files.some((entry) => entry.path.endsWith('.css'));
+    return [
+        boolResult('adikteev', 'package.fragment.html.required', hasHtml, 'Adikteev package should contain an HTML fragment/file.', 'Include the HTML fragment required by Adikteev.', inventory.packagePath),
+        boolResult('adikteev', 'package.fragment-js.required', hasJs, 'Adikteev package should contain separated JavaScript.', 'Separate JavaScript for CDN upload.', inventory.packagePath),
+        boolResult('adikteev', 'package.fragment-css.required', hasCss, 'Adikteev package should contain separated CSS.', 'Separate CSS for CDN upload.', inventory.packagePath),
+    ];
+}
+function fileEntries(inventory) {
+    return inventory.entries.filter((entry) => !entry.isDirectory);
+}
+function boolResult(channel, idSuffix, passed, message, recommendation, file, evidence) {
+    return {
+        ruleId: `${channel}.${idSuffix}`,
+        channel,
+        stage: 'delivery-package',
+        severity: 'error',
+        status: passed ? 'pass' : 'fail',
+        message: passed ? `${message}: passed` : message,
+        recommendation,
+        file,
+        evidence,
+        owner: 'playcraft-delivery',
+        confidence: 'high',
+    };
+}

package/dist/validation/profiles.d.ts

@@ -0,0 +1,5 @@
+import type { Platform } from '../types.js';
+import type { ChannelRuleProfile, ValidationRule, ValidationStage } from './types.js';
+export declare const CHANNEL_RULE_PROFILES: Record<Platform, ChannelRuleProfile>;
+export declare function getChannelRuleProfile(channel: Platform): ChannelRuleProfile;
+export declare function getRulesForStage(channel: Platform, stage: ValidationStage): ValidationRule[];

package/dist/validation/profiles.js

@@ -0,0 +1,222 @@
+const FIVE_MB = 5 * 1024 * 1024;
+const SOURCE_SPEC = 'temp-file/md/各渠道试玩广告规格-gemini.md';
+function sizeRule(channel) {
+    return {
+        id: `${channel}.artifact.size.max-5mb`,
+        title: 'Playable artifact must be smaller than 5 MB',
+        channel,
+        stage: 'html-artifact',
+        severity: 'error',
+        owner: 'playcraft-build',
+        detectable: true,
+        confidence: 'high',
+        description: 'Most playable ad channels cap the final creative artifact at 5 MB.',
+        recommendation: 'Compress or inline assets more aggressively, or remove unused media.',
+        evidenceType: 'file',
+        source: SOURCE_SPEC,
+        check: { kind: 'max-size', maxBytes: FIVE_MB },
+    };
+}
+function externalResourceRule(channel, allowedPatterns) {
+    return {
+        id: `${channel}.html.external-resource.forbidden`,
+        title: 'External runtime resources should not be loaded',
+        channel,
+        stage: 'html-artifact',
+        severity: 'error',
+        owner: 'playcraft-build',
+        detectable: true,
+        confidence: 'high',
+        description: 'Playable ads should not depend on external scripts, styles, images, media, or frames unless the channel explicitly provides that SDK.',
+        recommendation: 'Inline resources into the HTML artifact, or add a channel-specific allowlist when the SDK is officially required.',
+        evidenceType: 'pattern',
+        source: SOURCE_SPEC,
+        check: { kind: 'external-resources', allowedPatterns },
+    };
+}
+function forbiddenPatternRule(channel, idSuffix, title, pattern, recommendation, severity = 'error') {
+    return {
+        id: `${channel}.${idSuffix}`,
+        title,
+        channel,
+        stage: 'html-artifact',
+        severity,
+        owner: 'playcraft-build',
+        detectable: true,
+        confidence: 'high',
+        description: title,
+        recommendation,
+        evidenceType: 'pattern',
+        source: SOURCE_SPEC,
+        check: { kind: 'forbidden-pattern', pattern, flags: 'i' },
+    };
+}
+function requiredPatternRule(channel, idSuffix, title, pattern, recommendation, severity = 'error') {
+    return {
+        id: `${channel}.${idSuffix}`,
+        title,
+        channel,
+        stage: 'html-artifact',
+        severity,
+        owner: 'playcraft-build',
+        detectable: true,
+        confidence: 'high',
+        description: title,
+        recommendation,
+        evidenceType: 'pattern',
+        source: SOURCE_SPEC,
+        check: { kind: 'required-pattern', pattern, flags: 'i' },
+    };
+}
+function sourcePresenceRule(channel, idSuffix, title, recommendation) {
+    return {
+        id: `${channel}.${idSuffix}`,
+        title,
+        channel,
+        stage: 'prebuild-source',
+        severity: 'error',
+        owner: 'playcraft-build',
+        detectable: true,
+        confidence: 'high',
+        description: title,
+        recommendation,
+        evidenceType: 'pattern',
+        source: SOURCE_SPEC,
+    };
+}
+function manualRule(channel, idSuffix, title, recommendation) {
+    return {
+        id: `${channel}.${idSuffix}`,
+        title,
+        channel,
+        stage: 'runtime-manual',
+        severity: 'info',
+        owner: 'manual',
+        detectable: false,
+        confidence: 'medium',
+        description: title,
+        recommendation,
+        evidenceType: 'runtime',
+        source: SOURCE_SPEC,
+    };
+}
+function externalValidatorRule(channel, title, recommendation) {
+    return {
+        id: `${channel}.external-validator.review.required`,
+        title,
+        channel,
+        stage: 'external-validator',
+        severity: 'info',
+        owner: 'external',
+        detectable: false,
+        confidence: 'medium',
+        description: title,
+        recommendation,
+        evidenceType: 'external',
+        source: SOURCE_SPEC,
+    };
+}
+function profile(channel, displayName, deliveryMode, rules, options) {
+    return {
+        channel,
+        displayName,
+        defaultStages: ['prebuild-source', 'html-artifact'],
+        optionalStages: options?.optionalStages ?? [],
+        deliveryMode,
+        internalBuildFormat: options?.internalBuildFormat ?? 'html',
+        deliveryPackageFormat: options?.deliveryPackageFormat,
+        devkitOwned: options?.devkitOwned,
+        rules: [sizeRule(channel), ...rules],
+    };
+}
+export const CHANNEL_RULE_PROFILES = {
+    playcraft: {
+        channel: 'playcraft',
+        displayName: 'PlayCraft',
+        defaultStages: ['prebuild-source', 'html-artifact'],
+        optionalStages: [],
+        deliveryMode: 'mixed',
+        internalBuildFormat: 'html',
+        deliveryPackageFormat: 'mixed',
+        rules: [],
+    },
+    applovin: profile('applovin', 'AppLovin', 'single-html', [
+        externalResourceRule('applovin'),
+        requiredPatternRule('applovin', 'cta.mraid-open.required', 'CTA should use mraid.open()', '\\bmraid\\.open\\s*\\(', 'Route store jumps through mraid.open().'),
+        manualRule('applovin', 'runtime.orientation-and-cta.manual', 'Landscape, portrait, and CTA visibility need runtime review.', 'Verify both orientations and that CTA stays visible throughout the playable.'),
+        externalValidatorRule('applovin', 'AppLovin preview should be used before delivery.', 'Upload the final creative to AppLovin Preview or Preview Tool.'),
+    ], { optionalStages: ['runtime-manual', 'external-validator'] }),
+    google: profile('google', 'Google', 'html-backed-zip', [
+        externalResourceRule('google'),
+        forbiddenPatternRule('google', 'network.fetch.forbidden', 'Google creatives should not make runtime network requests.', '\\b(fetch|XMLHttpRequest|WebSocket|EventSource)\\b', 'Remove runtime network calls or mark approved analytics separately.'),
+        manualRule('google', 'runtime.audio-and-gesture.manual', 'Audio before interaction and download button animation need runtime review.', 'Confirm the creative is silent before interaction and CTA gestures do not scale improperly.'),
+        externalValidatorRule('google', 'Google H5 Validator should be used before delivery.', 'Validate the delivery package with Google H5 Validator.'),
+    ], { optionalStages: ['delivery-package', 'runtime-manual', 'external-validator'], deliveryPackageFormat: 'zip' }),
+    facebook: profile('facebook', 'Facebook / Meta', 'mixed', [
+        externalResourceRule('facebook'),
+        forbiddenPatternRule('facebook', 'sdk.mraid-js.forbidden', 'Facebook creatives should not include mraid.js.', 'mraid\\.js', 'Remove mraid.js and use Facebook playable APIs.'),
+        requiredPatternRule('facebook', 'cta.fb-on-click.recommended', 'CTA should call FbPlayableAd.onCTAClick().', 'FbPlayableAd\\.onCTAClick\\s*\\(', 'Route CTA clicks through FbPlayableAd.onCTAClick().', 'warning'),
+        manualRule('facebook', 'runtime.portrait-and-cta.manual', 'Portrait display and CTA clickability need runtime review.', 'Verify portrait layout and CTA behavior in Meta preview.'),
+    ], { optionalStages: ['delivery-package', 'runtime-manual'], deliveryPackageFormat: 'mixed' }),
+    tiktok: profile('tiktok', 'TikTok / Pangle', 'zip', [
+        forbiddenPatternRule('tiktok', 'sdk.mraid-js.forbidden', 'TikTok/Pangle creatives should not include mraid.js.', 'mraid\\.js', 'Remove mraid.js; Pangle integration belongs to the channel SDK.'),
+        forbiddenPatternRule('tiktok', 'redirect.javascript.forbidden', 'TikTok/Pangle creatives should not contain JavaScript redirects.', '\\blocation\\.(href|assign|replace)\\b|window\\.open\\s*\\(', 'Remove automatic redirects and delegate store jumps to Pangle.'),
+    ], { optionalStages: ['delivery-package'], deliveryPackageFormat: 'zip', devkitOwned: true, internalBuildFormat: 'delegated' }),
+    unity: profile('unity', 'Unity Ads', 'single-html', [
+        sourcePresenceRule('unity', 'mraid.viewable-change.required', 'Unity requires MRAID viewableChange before gameplay starts.', 'Add a viewableChange listener before starting playable content.'),
+        externalResourceRule('unity'),
+        requiredPatternRule('unity', 'cta.mraid-open.required', 'Unity CTA should use mraid.open().', '\\bmraid\\.open\\s*\\(', 'Route the CTA directly to the store through mraid.open().'),
+        requiredPatternRule('unity', 'mraid.viewable-change.required', 'Unity playable should wait for MRAID viewableChange.', 'viewableChange', 'Wait for the MRAID viewableChange event before starting gameplay.'),
+        manualRule('unity', 'runtime.orientation-and-start.manual', 'Orientation support and gameplay start timing need runtime review.', 'Verify portrait/landscape support and that gameplay waits for viewability.'),
+    ], { optionalStages: ['runtime-manual'] }),
+    ironsource: profile('ironsource', 'ironSource', 'mixed', [
+        forbiddenPatternRule('ironsource', 'redirect.auto.forbidden', 'ironSource creatives should not auto-redirect to the store.', '\\blocation\\.(href|assign|replace)\\b', 'Keep store jumps behind a user CTA.'),
+        manualRule('ironsource', 'runtime.loading-audio-controls.manual', 'Loading time, mute, close, and info buttons need runtime review.', 'Verify load time, audio behavior, mute button, close button, and info button.'),
+    ], { optionalStages: ['runtime-manual'], deliveryPackageFormat: 'mixed' }),
+    liftoff: profile('liftoff', 'Liftoff', 'zip', [
+        manualRule('liftoff', 'package.entry.manual', 'ZIP entry and folder structure need delivery review.', 'Confirm the ZIP has a single entry folder and a reachable root entry file.'),
+        externalValidatorRule('liftoff', 'Liftoff validator should be used before delivery.', 'Validate with Liftoff Interactive Ad Validator or Creative Verifier.'),
+    ], { optionalStages: ['delivery-package', 'external-validator'], deliveryPackageFormat: 'zip' }),
+    moloco: profile('moloco', 'Moloco', 'single-html', [
+        externalResourceRule('moloco'),
+        forbiddenPatternRule('moloco', 'sdk.mraid-js.forbidden', 'Moloco creatives should not include mraid.js.', 'mraid\\.js', 'Remove mraid.js and use Facebook-compatible CTA handling.'),
+        requiredPatternRule('moloco', 'cta.fb-on-click.required', 'Moloco CTA should use FbPlayableAd.onCTAClick().', 'FbPlayableAd\\.onCTAClick\\s*\\(', 'Route CTA clicks through FbPlayableAd.onCTAClick().'),
+        manualRule('moloco', 'runtime.portrait-responsive.manual', 'Portrait responsive behavior needs runtime review.', 'Verify portrait layout and CTA visibility.'),
+    ], { optionalStages: ['runtime-manual'] }),
+    bigo: profile('bigo', 'BIGO', 'zip', [
+        sourcePresenceRule('bigo', 'lifecycle.game-end.required', 'BIGO requires window.BGY_MRAID.gameEnd() when gameplay ends.', 'Call window.BGY_MRAID.gameEnd() when gameplay ends.'),
+        externalResourceRule('bigo', ['static-web.likeevideo.com']),
+        requiredPatternRule('bigo', 'cta.bgy-open.required', 'BIGO CTA should use window.BGY_MRAID.open().', 'window\\.BGY_MRAID\\.open\\s*\\(', 'Route CTA clicks through window.BGY_MRAID.open().'),
+        requiredPatternRule('bigo', 'lifecycle.game-end.required', 'BIGO creatives should call window.BGY_MRAID.gameEnd().', 'window\\.BGY_MRAID\\.gameEnd\\s*\\(', 'Call gameEnd() when gameplay ends.'),
+    ], { optionalStages: ['delivery-package'], deliveryPackageFormat: 'zip', devkitOwned: true, internalBuildFormat: 'delegated' }),
+    inmobi: profile('inmobi', 'InMobi', 'mixed', [
+        requiredPatternRule('inmobi', 'sdk.mraid-js.required', 'InMobi creatives should include mraid.js or MRAID support.', 'mraid', 'Include the channel-required MRAID integration.'),
+        requiredPatternRule('inmobi', 'cta.mraid-open.required', 'InMobi redirects should use mraid.open(url).', '\\bmraid\\.open\\s*\\(', 'Route store redirects through mraid.open(url).'),
+    ], { optionalStages: ['delivery-package', 'runtime-manual'], deliveryPackageFormat: 'mixed' }),
+    adikteev: profile('adikteev', 'Adikteev', 'fragment-assets', [
+        requiredPatternRule('adikteev', 'cta.mraid-open.required', 'Adikteev CTA should use mraid.open().', '\\bmraid\\.open\\s*\\(', 'Route CTA clicks through mraid.open().'),
+        requiredPatternRule('adikteev', 'click-pixel-url.required', 'Adikteev requires AK_CLICK_PIXEL_URL exposure.', 'AK_CLICK_PIXEL_URL|AK CLICK PIXEL URL', 'Expose the Adikteev click pixel URL variable.'),
+        manualRule('adikteev', 'runtime.cdn-responsive.manual', 'CDN resource loading and responsive layout need runtime review.', 'Verify separated assets load from Adikteev CDN and remain responsive.'),
+    ], { optionalStages: ['delivery-package', 'runtime-manual'], deliveryPackageFormat: 'fragment-assets' }),
+    remerge: profile('remerge', 'Remerge', 'single-html', [
+        externalResourceRule('remerge'),
+        forbiddenPatternRule('remerge', 'redirect.auto.forbidden', 'Remerge creatives should not auto-redirect to the store.', '\\blocation\\.(href|assign|replace)\\b', 'Keep store jumps behind a user CTA.'),
+    ]),
+    mintegral: profile('mintegral', 'Mintegral', 'mixed', [
+        sourcePresenceRule('mintegral', 'lifecycle.sdk-finish.required', 'Mintegral requires sdk.finish() after gameplay ends.', 'Call sdk.finish() when gameplay reaches win or end state.'),
+        requiredPatternRule('mintegral', 'lifecycle.sdk-finish.required', 'Mintegral creatives should call sdk.finish() after win or end.', '\\bsdk\\.finish\\s*\\(', 'Call sdk.finish() at the end of gameplay.'),
+        forbiddenPatternRule('mintegral', 'redirect.auto.forbidden', 'Mintegral creatives should not auto-redirect to the store.', '\\blocation\\.(href|assign|replace)\\b', 'Keep store jumps behind a user CTA.'),
+        externalValidatorRule('mintegral', 'Mindworks testing should be used before delivery.', 'Validate through the Mintegral/Mindworks testing entry.'),
+    ], { optionalStages: ['external-validator'], deliveryPackageFormat: 'mixed' }),
+    snapchat: profile('snapchat', 'Snapchat', 'zip', [
+        forbiddenPatternRule('snapchat', 'sdk.mraid-js.forbidden', 'Snapchat creatives should not include mraid.js.', 'mraid\\.js', 'Remove mraid.js and use Snapchat playable APIs.'),
+        requiredPatternRule('snapchat', 'cta.sc-on-click.required', 'Snapchat CTA should call ScPlayableAd.onCTAClick().', 'ScPlayableAd\\.onCTAClick\\s*\\(', 'Route CTA clicks through ScPlayableAd.onCTAClick().'),
+        manualRule('snapchat', 'runtime.portrait-and-cta.manual', 'Portrait display and CTA availability need runtime review.', 'Verify portrait layout and CTA behavior.'),
+    ], { optionalStages: ['delivery-package', 'runtime-manual'], deliveryPackageFormat: 'zip' }),
+};
+export function getChannelRuleProfile(channel) {
+    return CHANNEL_RULE_PROFILES[channel];
+}
+export function getRulesForStage(channel, stage) {
+    return getChannelRuleProfile(channel).rules.filter((rule) => rule.stage === stage);
+}

package/dist/validation/reporter.d.ts

@@ -0,0 +1,4 @@
+import type { ValidationReport } from './types.js';
+export declare function saveValidationReport(report: ValidationReport, reportPath: string): Promise<void>;
+export declare function formatValidationSummary(report: ValidationReport): string;
+export declare function hasBlockingValidationErrors(report: ValidationReport): boolean;

package/dist/validation/reporter.js

@@ -0,0 +1,30 @@
+import fs from 'fs/promises';
+import path from 'path';
+export async function saveValidationReport(report, reportPath) {
+    await fs.mkdir(path.dirname(reportPath), { recursive: true });
+    await fs.writeFile(reportPath, JSON.stringify(report, null, 2), 'utf-8');
+}
+export function formatValidationSummary(report) {
+    const lines = [
+        `[Validation] channel=${report.channel}, chain=${report.buildChain}, status=${report.summary.status}`,
+        `[Validation] errors=${report.summary.errorCount}, warnings=${report.summary.warningCount}, manual=${report.summary.manualCount}, external=${report.summary.externalCount}`,
+    ];
+    const failed = report.results.filter((result) => result.status === 'fail');
+    const warnings = report.results.filter((result) => result.status === 'warning');
+    for (const result of [...failed, ...warnings].slice(0, 10)) {
+        lines.push(`  - ${result.status.toUpperCase()} ${result.ruleId}: ${result.message}`);
+        if (result.file) {
+            lines.push(`    file=${result.file}${result.line ? `:${result.line}` : ''}`);
+        }
+        if (result.evidence) {
+            lines.push(`    evidence=${result.evidence}`);
+        }
+    }
+    if (failed.length + warnings.length > 10) {
+        lines.push(`  ... ${failed.length + warnings.length - 10} more validation results`);
+    }
+    return lines.join('\n');
+}
+export function hasBlockingValidationErrors(report) {
+    return report.results.some((result) => result.status === 'fail' && result.severity === 'error');
+}

package/dist/validation/source-scanner.d.ts

@@ -0,0 +1,4 @@
+import type { Platform } from '../types.js';
+import type { ValidationContext, ValidationResult } from './types.js';
+export declare function scanSourceForCompliance(context: ValidationContext): Promise<ValidationResult[]>;
+export declare function scanSourceForChannels(context: Omit<ValidationContext, 'channel'>, channels: Platform[]): Promise<ValidationResult[]>;