@playcraft/build 0.0.45 → 0.0.46

package/dist/base-builder.d.ts

@@ -30,6 +30,8 @@ export declare class BaseBuilder {
      * 根据构建工具路由到对应适配器
      */
     build(): Promise<BaseBuildOutput>;
+    private runPrebuildValidation;
+    private isPhaserValidationTarget;
     /**
      * 解析引擎类型和构建工具
      * 优先级：

package/dist/base-builder.js

@@ -1,4 +1,5 @@
 import { EngineDetector, PlayCanvasAdapter, GenericAdapter, PlayableScriptsAdapter } from './engines/index.js';
+import { formatValidationSummary, hasBlockingValidationErrors, runPlayableValidation, saveValidationReport, } from './validation/index.js';
 /**
  * 基础构建器 - 路由到不同构建工具适配器
  *
@@ -33,6 +34,7 @@ export class BaseBuilder {
         // 1. 确定引擎类型和构建工具
         const { engine, buildTool } = await this.resolveDetection();
         console.log(`[BaseBuilder] 使用引擎: ${engine}, 构建工具: ${buildTool}`);
+        await this.runPrebuildValidation(engine, buildTool);
         // 2. 根据构建工具路由到对应适配器
         let result;
         switch (buildTool) {
@@ -57,6 +59,48 @@ export class BaseBuilder {
         this._metadata = result.metadata;
         return result;
     }
+    async runPrebuildValidation(engine, buildTool) {
+        const validationOptions = this.options.validation;
+        if (validationOptions?.enabled === false || validationOptions?.sourcePrechecked || !validationOptions?.channel) {
+            return;
+        }
+        if (!this.isPhaserValidationTarget(engine, buildTool)) {
+            return;
+        }
+        const requestedStages = validationOptions.stages;
+        if (requestedStages && !requestedStages.includes('prebuild-source')) {
+            return;
+        }
+        const stages = ['prebuild-source'];
+        const report = await runPlayableValidation({
+            projectRoot: this.projectDir,
+            channel: validationOptions.channel,
+            engine,
+            buildTool,
+            buildChain: buildTool === 'playable-scripts'
+                ? 'devkit'
+                : buildTool === 'playcanvas-native'
+                    ? 'playcanvas-native'
+                    : 'generic',
+            sourceGlobs: validationOptions.sourceGlobs,
+        }, stages);
+        const summary = formatValidationSummary(report);
+        if (report.summary.status === 'pass') {
+            console.log(summary);
+        }
+        else {
+            console.warn(summary);
+        }
+        if (validationOptions.reportPath) {
+            await saveValidationReport(report, validationOptions.reportPath);
+        }
+        if (validationOptions.failOnError && hasBlockingValidationErrors(report)) {
+            throw new Error(`Prebuild validation failed for ${validationOptions.channel}`);
+        }
+    }
+    isPhaserValidationTarget(engine, buildTool) {
+        return engine === 'phaser' || buildTool === 'playable-scripts';
+    }
     /**
      * 解析引擎类型和构建工具
      * 优先级：

package/dist/engines/playable-scripts-adapter.d.ts

@@ -155,6 +155,11 @@ export declare class PlayableScriptsAdapter {
      * 获取平台默认的文件名格式
      */
     private getPlatformFilename;
+    private runDevkitOutputValidation;
+    private getValidationChannels;
+    private isSupportedValidationChannel;
+    private pickArtifactForChannel;
+    private reportPathForChannel;
     private saveBuildMetadata;
     /**
      * 执行命令并设置超时

package/dist/engines/playable-scripts-adapter.js

@@ -3,6 +3,7 @@ import path from 'path';
 import { spawn } from 'child_process';
 import { fileURLToPath } from 'url';
 import { createRequire } from 'module';
+import { formatValidationSummary, hasBlockingValidationErrors, runPlayableValidation, saveValidationReport, } from '../validation/index.js';
 // ESM 兼容：获取当前模块的目录路径
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -92,6 +93,7 @@ export class PlayableScriptsAdapter {
         const outputs = await this.collectOutputs();
         // 7. 复制产物到 PlayCraft outputDir
         const files = await this.copyToOutputDir(outputs);
+        await this.runDevkitOutputValidation(files);
         // 7. 构建元数据
         const metadata = {
             mode: 'classic',
@@ -1236,6 +1238,94 @@ export class PlayableScriptsAdapter {
         return platformFileNames[channel] || 'index';
     }
     // ==================== 9. 保存元数据 ====================
+    async runDevkitOutputValidation(files) {
+        const validationOptions = this.options.validation;
+        if (validationOptions?.enabled === false) {
+            return;
+        }
+        const channels = this.getValidationChannels();
+        const artifacts = files.assets.filter((file) => file.endsWith('.html') || file.endsWith('.zip'));
+        if (channels.length === 0 || artifacts.length === 0) {
+            return;
+        }
+        const requestedStages = validationOptions?.stages;
+        for (const channel of channels) {
+            const artifact = this.pickArtifactForChannel(channel, artifacts);
+            if (!artifact) {
+                continue;
+            }
+            const isZip = artifact.toLowerCase().endsWith('.zip');
+            const stages = requestedStages ?? (isZip ? ['delivery-package'] : ['html-artifact']);
+            const report = await runPlayableValidation({
+                projectRoot: this.projectDir,
+                channel,
+                engine: 'phaser',
+                buildTool: 'playable-scripts',
+                buildChain: 'devkit',
+                htmlPath: isZip ? undefined : artifact,
+                packagePath: isZip ? artifact : undefined,
+                outputDir: this.options.outputDir,
+                sourceGlobs: validationOptions?.sourceGlobs,
+            }, stages);
+            const summary = formatValidationSummary(report);
+            if (report.summary.status === 'pass') {
+                console.log(summary);
+            }
+            else {
+                console.warn(summary);
+            }
+            if (validationOptions?.reportPath) {
+                await saveValidationReport(report, this.reportPathForChannel(validationOptions.reportPath, channel, channels.length));
+            }
+            if (validationOptions?.failOnError && hasBlockingValidationErrors(report)) {
+                throw new Error(`Playable validation failed for ${channel}`);
+            }
+        }
+    }
+    getValidationChannels() {
+        if (this.options.validation?.channel) {
+            return [this.options.validation.channel];
+        }
+        const channels = this.config?.channels ?? [];
+        return channels.filter((channel) => this.isSupportedValidationChannel(channel));
+    }
+    isSupportedValidationChannel(channel) {
+        const supported = [
+            'playcraft',
+            'facebook',
+            'snapchat',
+            'ironsource',
+            'applovin',
+            'google',
+            'tiktok',
+            'unity',
+            'liftoff',
+            'moloco',
+            'bigo',
+            'inmobi',
+            'adikteev',
+            'remerge',
+            'mintegral',
+        ];
+        return supported.includes(channel);
+    }
+    pickArtifactForChannel(channel, artifacts) {
+        if (artifacts.length === 1) {
+            return artifacts[0];
+        }
+        const direct = artifacts.find((artifact) => {
+            const normalized = artifact.replace(/\\/g, '/').toLowerCase();
+            return normalized.includes(`/${channel}/`) || normalized.includes(`-${channel}.`);
+        });
+        return direct ?? artifacts[0];
+    }
+    reportPathForChannel(reportPath, channel, channelCount) {
+        if (channelCount <= 1) {
+            return reportPath;
+        }
+        const parsed = path.parse(reportPath);
+        return path.join(parsed.dir, `${parsed.name}.${channel}${parsed.ext || '.json'}`);
+    }
     async saveBuildMetadata(metadata) {
         // 不再保存 .build-metadata.json 文件，元数据通过返回值传递
         console.log(`[PlayableScriptsAdapter] 构建完成（buildTool: playable-scripts, skipChannelBuild: true）`);

package/dist/index.d.ts

@@ -25,4 +25,5 @@ export { PLATFORM_CONFIGS } from './vite/platform-configs.js';
 export type { PlatformViteConfig } from './vite/platform-configs.js';
 export { AudioOptimizer } from './audio-optimizer.js';
 export type { AudioAssetInfo, AudioOptimizationReport, AudioOptimizerOptions } from './audio-optimizer.js';
+export * from './validation/index.js';
 export * from './types.js';

package/dist/index.js

@@ -23,4 +23,5 @@ export { PLATFORM_CONFIGS } from './vite/platform-configs.js';
 // 导出音频优化器
 export { AudioOptimizer } from './audio-optimizer.js';
 // 导出类型
+export * from './validation/index.js';
 export * from './types.js';

package/dist/types.d.ts

@@ -7,6 +7,16 @@ export interface StoreUrls {
     ios?: string;
     android?: string;
 }
+export interface ComplianceValidationOptions {
+    enabled?: boolean;
+    failOnError?: boolean;
+    channel?: Platform;
+    reportPath?: string;
+    sourcePrechecked?: boolean;
+    stages?: Array<'prebuild-source' | 'base-output' | 'html-artifact' | 'delivery-package' | 'runtime-manual' | 'external-validator'>;
+    sourceGlobs?: string[];
+    sourceDebug?: unknown;
+}
 export type BuildMode = 'classic' | 'esm';
 export type ESMMode = 'auto' | 'enabled' | 'disabled';
 export interface BuildOptions {
@@ -48,6 +58,7 @@ export interface BuildOptions {
     preserveESM?: boolean;
     forceIIFE?: boolean;
     storeUrls?: StoreUrls;
+    validation?: ComplianceValidationOptions;
     tracking?: {
         enabled?: boolean;
         adNetwork?: string;
@@ -208,6 +219,7 @@ export interface BaseBuildOptions {
     engine?: EngineType;
     /** 渠道产物格式（playable-scripts 阶段；与 Vite 阶段 format 对齐） */
     format?: OutputFormat;
+    validation?: ComplianceValidationOptions;
 }
 /**
  * 基础构建输出
@@ -268,4 +280,5 @@ export interface BuildOptions {
     forceIIFE?: boolean;
     engine?: EngineType;
     storeUrls?: StoreUrls;
+    validation?: ComplianceValidationOptions;
 }

package/dist/validation/html-validator.d.ts

@@ -0,0 +1,2 @@
+import type { ChannelRuleProfile, ValidationContext, ValidationResult } from './types.js';
+export declare function validateHtmlArtifact(context: ValidationContext, profile?: ChannelRuleProfile): Promise<ValidationResult[]>;

package/dist/validation/html-validator.js

@@ -0,0 +1,140 @@
+import fs from 'fs/promises';
+import { getRulesForStage } from './profiles.js';
+const RESOURCE_ATTR_RE = /\b(?:src|href|data)\s*=\s*["']([^"']+)["']/gi;
+const CSS_URL_RE = /url\(\s*["']?([^"')]+)["']?\s*\)/gi;
+export async function validateHtmlArtifact(context, profile) {
+    const rules = profile?.rules.filter((rule) => rule.stage === 'html-artifact')
+        ?? getRulesForStage(context.channel, 'html-artifact');
+    if (!context.htmlPath) {
+        return [missingHtmlResult(context.channel)];
+    }
+    let artifact;
+    try {
+        const [content, stat] = await Promise.all([
+            fs.readFile(context.htmlPath, 'utf-8'),
+            fs.stat(context.htmlPath),
+        ]);
+        artifact = {
+            path: context.htmlPath,
+            content,
+            size: stat.size,
+        };
+    }
+    catch (error) {
+        return [missingHtmlResult(context.channel, context.htmlPath, error)];
+    }
+    const results = [];
+    for (const rule of rules) {
+        if (!rule.detectable || !rule.check) {
+            continue;
+        }
+        results.push(evaluateHtmlRule(rule, artifact));
+    }
+    return results;
+}
+function missingHtmlResult(channel, htmlPath, error) {
+    return {
+        ruleId: `${channel}.html.entry.exists`,
+        channel,
+        stage: 'html-artifact',
+        severity: 'error',
+        status: 'fail',
+        message: htmlPath
+            ? `HTML artifact is not readable: ${htmlPath}`
+            : 'HTML artifact path is missing.',
+        recommendation: 'Pass the final channel HTML artifact path to the validation context.',
+        file: htmlPath,
+        evidence: error instanceof Error ? error.message : undefined,
+        owner: 'playcraft-build',
+        confidence: 'high',
+    };
+}
+function evaluateHtmlRule(rule, artifact) {
+    const check = rule.check;
+    switch (check.kind) {
+        case 'max-size':
+            return resultFromBoolean(rule, artifact.size <= check.maxBytes, artifact.path, `actual=${formatBytes(artifact.size)}, limit=${formatBytes(check.maxBytes)}`);
+        case 'external-resources': {
+            const externalResources = collectExternalResources(artifact.content)
+                .filter((url) => !isAllowedExternalResource(url, check.allowedPatterns));
+            return resultFromBoolean(rule, externalResources.length === 0, artifact.path, externalResources.slice(0, 20).join(', '));
+        }
+        case 'required-pattern': {
+            const regex = new RegExp(check.pattern, check.flags);
+            return resultFromBoolean(rule, regex.test(artifact.content), artifact.path, check.evidence ?? check.pattern);
+        }
+        case 'forbidden-pattern': {
+            const regex = new RegExp(check.pattern, check.flags);
+            const match = artifact.content.match(regex);
+            return resultFromBoolean(rule, !match, artifact.path, match?.[0] ?? check.evidence ?? check.pattern);
+        }
+        case 'single-html':
+            return resultFromBoolean(rule, collectLocalResourceReferences(artifact.content).length === 0, artifact.path, collectLocalResourceReferences(artifact.content).slice(0, 20).join(', '));
+    }
+}
+function resultFromBoolean(rule, passed, file, evidence) {
+    return {
+        ruleId: rule.id,
+        channel: rule.channel,
+        stage: rule.stage,
+        severity: rule.severity,
+        status: passed ? 'pass' : (rule.severity === 'error' ? 'fail' : 'warning'),
+        message: passed ? `${rule.title}: passed` : rule.title,
+        recommendation: rule.recommendation,
+        file,
+        evidence: evidence || undefined,
+        owner: rule.owner,
+        confidence: rule.confidence,
+    };
+}
+function collectExternalResources(html) {
+    return collectUrls(html).filter((url) => /^https?:\/\//i.test(url) || /^\/\//.test(url));
+}
+function collectLocalResourceReferences(html) {
+    return collectUrls(html).filter((url) => {
+        if (isInlineOrSpecialUrl(url))
+            return false;
+        if (/^https?:\/\//i.test(url) || /^\/\//.test(url))
+            return false;
+        return !url.startsWith('#');
+    });
+}
+function collectUrls(html) {
+    const urls = new Set();
+    for (const match of html.matchAll(RESOURCE_ATTR_RE)) {
+        if (match[1])
+            urls.add(match[1].trim());
+    }
+    for (const match of html.matchAll(CSS_URL_RE)) {
+        if (match[1])
+            urls.add(match[1].trim());
+    }
+    return Array.from(urls);
+}
+function isInlineOrSpecialUrl(url) {
+    return /^(data:|blob:|javascript:|mailto:|tel:|about:)/i.test(url);
+}
+function isAllowedExternalResource(url, allowedPatterns) {
+    if (!allowedPatterns || allowedPatterns.length === 0) {
+        return false;
+    }
+    return allowedPatterns.some((pattern) => {
+        if (url.includes(pattern))
+            return true;
+        try {
+            return new RegExp(pattern, 'i').test(url);
+        }
+        catch {
+            return false;
+        }
+    });
+}
+function formatBytes(bytes) {
+    if (!Number.isFinite(bytes))
+        return String(bytes);
+    const mb = bytes / 1024 / 1024;
+    if (mb >= 1)
+        return `${mb.toFixed(2)} MB`;
+    const kb = bytes / 1024;
+    return `${kb.toFixed(1)} KB`;
+}

package/dist/validation/index.d.ts

@@ -0,0 +1,8 @@
+export * from './types.js';
+export * from './profiles.js';
+export * from './html-validator.js';
+export * from './package-validator.js';
+export * from './reporter.js';
+export * from './source-scanner.js';
+export * from './validation-runner.js';
+export * from './zip-reader.js';

package/dist/validation/index.js

@@ -0,0 +1,8 @@
+export * from './types.js';
+export * from './profiles.js';
+export * from './html-validator.js';
+export * from './package-validator.js';
+export * from './reporter.js';
+export * from './source-scanner.js';
+export * from './validation-runner.js';
+export * from './zip-reader.js';

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

@@ -0,0 +1,2 @@
+import type { ChannelRuleProfile, ValidationContext, ValidationResult } from './types.js';
+export declare function validateDeliveryPackage(context: ValidationContext, profile?: ChannelRuleProfile): Promise<ValidationResult[]>;

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[];