@playcraft/cli 0.0.43 → 0.0.44

package/dist/playable/vite-builder.js

@@ -1,125 +0,0 @@
-import { build as viteBuild } from 'vite';
-import fs from 'fs/promises';
-import path from 'path';
-import { ViteConfigBuilder } from './vite/config-builder.js';
-import { PLATFORM_CONFIGS } from './vite/platform-configs.js';
-/**
- * Vite 构建器 - 使用 Vite 构建 Playable Ads
- *
- * 职责：
- * 1. 验证输入是有效的基础构建
- * 2. 创建 Vite 配置
- * 3. 执行 Vite 构建
- * 4. 验证输出大小
- * 5. 生成报告
- */
-export class ViteBuilder {
-    baseBuildDir;
-    options;
-    sizeReport;
-    constructor(baseBuildDir, options) {
-        this.baseBuildDir = baseBuildDir;
-        this.options = options;
-        const platformConfig = PLATFORM_CONFIGS[options.platform];
-        this.sizeReport = {
-            engine: 0,
-            assets: {},
-            total: 0,
-            limit: platformConfig.sizeLimit,
-        };
-    }
-    /**
-     * 执行构建
-     */
-    async build() {
-        // 1. 验证输入
-        await this.validateBaseBuild();
-        // 2. 创建 Vite 配置
-        const configBuilder = new ViteConfigBuilder(this.baseBuildDir, this.options.platform, this.options);
-        const viteConfig = configBuilder.create();
-        // 3. 执行 Vite 构建
-        await viteBuild(viteConfig);
-        // 4. 验证输出大小
-        const outputPath = this.getOutputPath();
-        await this.validateSize(outputPath);
-        // 5. 生成报告
-        this.generateReport(outputPath);
-        return outputPath;
-    }
-    /**
-     * 验证基础构建
-     */
-    async validateBaseBuild() {
-        const requiredFiles = [
-            'index.html',
-            'config.json',
-            '__start__.js',
-        ];
-        const missingFiles = [];
-        for (const file of requiredFiles) {
-            try {
-                await fs.access(path.join(this.baseBuildDir, file));
-            }
-            catch (error) {
-                missingFiles.push(file);
-            }
-        }
-        if (missingFiles.length > 0) {
-            throw new Error(`基础构建产物缺少必需文件: ${missingFiles.join(', ')}\n` +
-                `请确保输入目录包含完整的多文件构建产物。`);
-        }
-    }
-    /**
-     * 获取输出路径
-     */
-    getOutputPath() {
-        const platformConfig = PLATFORM_CONFIGS[this.options.platform];
-        const outputDir = this.options.outputDir || './dist';
-        if (platformConfig.outputFormat === 'zip') {
-            return path.join(outputDir, 'playable.zip');
-        }
-        return path.join(outputDir, platformConfig.outputFileName);
-    }
-    /**
-     * 验证输出大小
-     */
-    async validateSize(outputPath) {
-        try {
-            const stats = await fs.stat(outputPath);
-            this.sizeReport.total = stats.size;
-            this.sizeReport.assets[path.basename(outputPath)] = stats.size;
-            if (stats.size > this.sizeReport.limit) {
-                const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
-                const limitMB = (this.sizeReport.limit / 1024 / 1024).toFixed(2);
-                console.warn(`⚠️  警告: 文件大小 ${sizeMB} MB 超过限制 ${limitMB} MB`);
-            }
-        }
-        catch (error) {
-            console.warn(`警告: 无法读取输出文件: ${outputPath}`);
-        }
-    }
-    /**
-     * 生成报告
-     */
-    generateReport(outputPath) {
-        // 报告已在 validateSize 中生成
-        // 这里可以添加额外的报告逻辑
-    }
-    /**
-     * 获取大小报告
-     */
-    getSizeReport() {
-        return this.sizeReport;
-    }
-    /**
-     * 格式化字节数
-     */
-    formatBytes(bytes) {
-        if (bytes === 0)
-            return '0 Bytes';
-        const k = 1024;
-        const sizes = ['Bytes', 'KB', 'MB', 'GB'];
-        const i = Math.floor(Math.log(bytes) / Math.log(k));
-        return Math.round(bytes / Math.pow(k, i) * 100) / 100 + ' ' + sizes[i];
-    }
-}

package/dist/prad/atom-ref.js

@@ -1,23 +0,0 @@
-/** Parse entity/engine atom field (string or object). */
-export function parseAtomRef(raw) {
-    if (typeof raw === 'string') {
-        return { id: raw, resolve: 'registry' };
-    }
-    if (raw && typeof raw === 'object' && 'id' in raw) {
-        const o = raw;
-        if (typeof o.id !== 'string')
-            return null;
-        return {
-            id: o.id,
-            resolve: o.resolve ?? 'registry',
-            substitute: o.substitute,
-        };
-    }
-    return null;
-}
-export function atomIdFromInstance(raw) {
-    if (raw && typeof raw === 'object' && 'atom' in raw) {
-        return parseAtomRef(raw.atom)?.id ?? null;
-    }
-    return null;
-}

package/dist/prad/check.js

@@ -1,377 +0,0 @@
-import * as fs from 'node:fs';
-import { atomIdFromInstance, parseAtomRef } from './atom-ref.js';
-import { loadGateRequirements, loadSpineRegistry } from './load-spec.js';
-import { walkPradDocument, parentEntityPath, resolvePath } from './paths.js';
-import { effectiveAtomId, loadManifestImports, loadRegistryAtomIds, } from './skills-index.js';
-function pushIssue(list, issue) {
-    list.push(issue);
-}
-function collectAtomRefsFromDoc(doc) {
-    const map = new Map();
-    const engine = doc.engine;
-    const engineRef = typeof engine === 'string' ? parseAtomRef(engine) : parseAtomRef(engine?.atom);
-    if (engineRef)
-        map.set(engineRef.id, engineRef);
-    const remixSpec = doc.meta?.remixSpec;
-    const remixAtom = atomIdFromInstance(remixSpec);
-    if (remixAtom) {
-        const ref = parseAtomRef(remixSpec.atom);
-        if (ref)
-            map.set(ref.id, ref);
-    }
-    for (const visit of walkPradDocument(doc)) {
-        if (visit.kind === 'entity' && visit.entity) {
-            const ref = parseAtomRef(visit.entity.atom);
-            if (ref)
-                map.set(ref.id, ref);
-        }
-        if (visit.mediaInstance) {
-            const ref = parseAtomRef(visit.mediaInstance.atom);
-            if (ref)
-                map.set(ref.id, ref);
-        }
-    }
-    return map;
-}
-function parseLedger(doc) {
-    const ledger = new Map();
-    const meta = doc.meta;
-    for (const entry of meta?.atomLedger ?? []) {
-        if (entry?.id)
-            ledger.set(entry.id, entry);
-    }
-    return ledger;
-}
-export function checkPradDocument(doc, options = {}) {
-    const errors = [];
-    const warnings = [];
-    const gate = options.gate ?? doc.meta?.gate ?? 4;
-    const meta = doc.meta;
-    const pradVersion = meta?.pradVersion;
-    if (!pradVersion && !options.legacy) {
-        pushIssue(warnings, {
-            code: 'PRAD-W001',
-            severity: 'warning',
-            path: 'meta.pradVersion',
-            message: 'Missing pradVersion; treat as legacy v0.1',
-        });
-    }
-    const isV02Plus = pradVersion === '0.2' || pradVersion === '0.2.1';
-    const isV021 = pradVersion === '0.2.1';
-    const registry = loadRegistryAtomIds(options.skillsDir);
-    const spineReg = loadSpineRegistry(options.specDir);
-    const gateReq = loadGateRequirements(options.specDir);
-    const gateConfig = gateReq.gates[String(gate)];
-    const docAtoms = collectAtomRefsFromDoc(doc);
-    const ledger = parseLedger(doc);
-    // S2: atom resolve
-    for (const [atomId, ref] of docAtoms) {
-        if (ref.resolve === 'draft') {
-            const issue = {
-                code: options.strictDrafts ? 'PRAD-E020' : 'PRAD-W020',
-                severity: options.strictDrafts ? 'error' : 'warning',
-                path: atomId,
-                message: `Draft atom "${atomId}"${ref.substitute ? ` (substitute: ${ref.substitute})` : ''}`,
-            };
-            if (ref.substitute && !registry.has(ref.substitute)) {
-                pushIssue(errors, {
-                    code: 'PRAD-E023',
-                    severity: 'error',
-                    path: atomId,
-                    message: `Draft substitute "${ref.substitute}" not in Skills registry`,
-                });
-            }
-            else if (!ref.substitute) {
-                pushIssue(errors, {
-                    code: 'PRAD-E023',
-                    severity: 'error',
-                    path: atomId,
-                    message: `Draft atom "${atomId}" missing substitute`,
-                });
-            }
-            else {
-                pushIssue(options.strictDrafts ? errors : warnings, issue);
-            }
-        }
-        else if (!registry.has(atomId)) {
-            pushIssue(errors, {
-                code: 'PRAD-E020',
-                severity: 'error',
-                path: atomId,
-                message: `Unknown registry atom "${atomId}"`,
-            });
-        }
-    }
-    // S2b: atomLedger consistency
-    if (isV02Plus && gate >= 4) {
-        if (!meta?.atomLedger?.length) {
-            pushIssue(errors, {
-                code: 'PRAD-E022',
-                severity: 'error',
-                path: 'meta.atomLedger',
-                message: 'Gate 4 requires meta.atomLedger',
-            });
-        }
-    }
-    for (const [atomId, ref] of docAtoms) {
-        const ledgerEntry = ledger.get(atomId);
-        if (isV02Plus && gate >= 2 && !ledgerEntry) {
-            pushIssue(warnings, {
-                code: 'PRAD-E022',
-                severity: 'warning',
-                path: 'meta.atomLedger',
-                message: `Atom "${atomId}" used in document but missing from atomLedger`,
-            });
-        }
-        if (ledgerEntry && ledgerEntry.resolve !== ref.resolve) {
-            pushIssue(errors, {
-                code: 'PRAD-E022',
-                severity: 'error',
-                path: 'meta.atomLedger',
-                message: `Ledger resolve for "${atomId}" (${ledgerEntry.resolve}) != node (${ref.resolve})`,
-            });
-        }
-    }
-    for (const [atomId, entry] of ledger) {
-        if (entry.resolve === 'draft' && !entry.substitute) {
-            pushIssue(errors, {
-                code: 'PRAD-E023',
-                severity: 'error',
-                path: 'meta.atomLedger',
-                message: `Ledger draft "${atomId}" missing substitute`,
-            });
-        }
-        if (entry.resolve === 'draft' && entry.substitute && !registry.has(entry.substitute)) {
-            pushIssue(errors, {
-                code: 'PRAD-E023',
-                severity: 'error',
-                path: 'meta.atomLedger',
-                message: `Ledger substitute "${entry.substitute}" for "${atomId}" not in registry`,
-            });
-        }
-    }
-    if (isV02Plus && gate >= 4 && gateConfig?.requiredMeta?.includes('atomLedger')) {
-        for (const [atomId, ref] of docAtoms) {
-            if (ref.resolve === 'draft' && gate >= 4) {
-                pushIssue(warnings, {
-                    code: 'PRAD-W020',
-                    severity: 'warning',
-                    path: atomId,
-                    message: `Gate 4 document still contains draft atom "${atomId}" (compile uses substitute)`,
-                });
-            }
-        }
-    }
-    // S5: slot vs spine-registry
-    const presentSpines = new Set();
-    if (isV02Plus && gateConfig?.entitySlotRequired) {
-        for (const visit of walkPradDocument(doc)) {
-            if (visit.kind !== 'entity' || !visit.entity)
-                continue;
-            const slot = visit.entity.slot;
-            const sinceGate = visit.entity.sinceGate;
-            if (!slot?.spine) {
-                pushIssue(errors, {
-                    code: 'PRAD-E025',
-                    severity: 'error',
-                    path: visit.path,
-                    message: 'Entity missing slot.spine (required Gate 3+)',
-                });
-                continue;
-            }
-            if (!spineReg.spines[slot.spine]) {
-                pushIssue(errors, {
-                    code: 'PRAD-E025',
-                    severity: 'error',
-                    path: visit.path,
-                    message: `Unknown spine "${slot.spine}"`,
-                });
-            }
-            else {
-                presentSpines.add(slot.spine);
-            }
-            if (sinceGate != null && meta?.gate != null && sinceGate > meta.gate) {
-                pushIssue(errors, {
-                    code: 'PRAD-E027',
-                    severity: 'error',
-                    path: visit.path,
-                    message: `sinceGate ${sinceGate} > meta.gate ${meta.gate}`,
-                });
-            }
-            if (sinceGate != null && sinceGate > gate) {
-                pushIssue(errors, {
-                    code: 'PRAD-E027',
-                    severity: 'error',
-                    path: visit.path,
-                    message: `sinceGate ${sinceGate} > check gate ${gate}`,
-                });
-            }
-        }
-    }
-    for (const req of gateConfig?.requiredSpines ?? []) {
-        if (req.criticality !== 'required')
-            continue;
-        const spine = spineReg.spines[req.spine];
-        if (spine?.globalsKey) {
-            const globals = doc.globals;
-            if (!globals?.[spine.globalsKey]) {
-                pushIssue(errors, {
-                    code: 'PRAD-E040',
-                    severity: 'error',
-                    path: `globals.${spine.globalsKey}`,
-                    message: `Required spine ${req.spine} (globals.${spine.globalsKey}) missing`,
-                });
-            }
-            continue;
-        }
-        if (spine?.topLevelKey) {
-            if (!(spine.topLevelKey in doc)) {
-                pushIssue(errors, {
-                    code: 'PRAD-E040',
-                    severity: 'error',
-                    path: spine.topLevelKey,
-                    message: `Required spine ${req.spine} (${spine.topLevelKey}) missing`,
-                });
-            }
-            continue;
-        }
-        if (spine?.metaKey) {
-            const metaObj = doc.meta;
-            if (!metaObj?.[spine.metaKey]) {
-                pushIssue(errors, {
-                    code: 'PRAD-E040',
-                    severity: 'error',
-                    path: `meta.${spine.metaKey}`,
-                    message: `Required spine ${req.spine} (meta.${spine.metaKey}) missing`,
-                });
-            }
-            continue;
-        }
-        if (!presentSpines.has(req.spine)) {
-            pushIssue(errors, {
-                code: 'PRAD-E040',
-                severity: 'error',
-                path: req.spine,
-                message: `Required spine ${req.spine} not present on any entity`,
-            });
-        }
-    }
-    // S3b: bindAs on media (Gate 2+ when enabled)
-    if (isV02Plus && gate >= 2 && gateConfig?.bindAsRequiredOnMedia !== false) {
-        for (const visit of walkPradDocument(doc)) {
-            if (visit.kind === 'global') {
-                const inst = visit.mediaInstance;
-                if (!inst?.bindAs) {
-                    pushIssue(gate >= 4 ? errors : warnings, {
-                        code: 'PRAD-E026',
-                        severity: gate >= 4 ? 'error' : 'warning',
-                        path: visit.path,
-                        message: 'Global atom instance missing bindAs',
-                    });
-                }
-                continue;
-            }
-            if (visit.kind !== 'media' || !visit.mediaInstance || !visit.parentEntityAtom)
-                continue;
-            const bindAs = visit.mediaInstance.bindAs;
-            if (!bindAs) {
-                pushIssue(gate >= 4 ? errors : warnings, {
-                    code: 'PRAD-E026',
-                    severity: gate >= 4 ? 'error' : 'warning',
-                    path: visit.path,
-                    message: 'Media instance missing bindAs',
-                });
-                continue;
-            }
-            if (bindAs.startsWith('globals.'))
-                continue;
-            const bindTargetRef = visit.mediaInstance.bindTargetRef;
-            let targetEntityPath;
-            let targetEntityAtom;
-            if (bindTargetRef) {
-                if (!isV021) {
-                    pushIssue(warnings, {
-                        code: 'PRAD-W021',
-                        severity: 'warning',
-                        path: visit.path,
-                        message: 'bindTargetRef ignored on pradVersion < 0.2.1',
-                    });
-                    targetEntityPath = parentEntityPath(visit.path);
-                    targetEntityAtom = visit.parentEntityAtom;
-                }
-                else {
-                    const targetVisit = resolvePath(doc, bindTargetRef);
-                    if (!targetVisit || targetVisit.kind !== 'entity' || !targetVisit.entity) {
-                        pushIssue(errors, {
-                            code: 'PRAD-E028',
-                            severity: 'error',
-                            path: visit.path,
-                            message: `bindTargetRef "${bindTargetRef}" is not a valid entity path`,
-                        });
-                        continue;
-                    }
-                    targetEntityPath = bindTargetRef;
-                    targetEntityAtom = parseAtomRef(targetVisit.entity.atom) ?? undefined;
-                    if (!targetEntityAtom)
-                        continue;
-                }
-            }
-            else {
-                targetEntityPath = parentEntityPath(visit.path);
-                targetEntityAtom = visit.parentEntityAtom;
-            }
-            const targetEffective = effectiveAtomId(targetEntityAtom);
-            const imports = loadManifestImports(targetEffective, options.skillsDir);
-            const e026Severity = isV021 && gate >= 4 ? 'error' : 'warning';
-            const e026List = isV021 && gate >= 4 ? errors : warnings;
-            if (!imports || imports.bindAsSet.size === 0) {
-                if (isV021 && gate >= 4) {
-                    pushIssue(e026List, {
-                        code: 'PRAD-E026',
-                        severity: e026Severity,
-                        path: visit.path,
-                        message: `bindAs "${bindAs}" targets ${targetEffective} which has no manifest imports`,
-                    });
-                }
-                else if (imports && imports.bindAsSet.size > 0) {
-                    // unreachable
-                }
-                continue;
-            }
-            if (!imports.bindAsSet.has(bindAs)) {
-                pushIssue(e026List, {
-                    code: 'PRAD-E026',
-                    severity: e026Severity,
-                    path: visit.path,
-                    message: `bindAs "${bindAs}" not in ${targetEffective} manifest imports (known: ${[...imports.bindAsSet].join(', ')})`,
-                });
-            }
-        }
-    }
-    // Gate 4 review
-    if (gate >= 4) {
-        const review = doc.review;
-        if (!review) {
-            pushIssue(errors, { code: 'PRAD-E050', severity: 'error', path: 'review', message: 'Missing review block' });
-        }
-        else if (review.pass !== true) {
-            pushIssue(errors, { code: 'PRAD-E050', severity: 'error', path: 'review.pass', message: 'review.pass must be true' });
-        }
-    }
-    return { ok: errors.length === 0, errors, warnings };
-}
-export function checkPradFile(filePath, options = {}) {
-    const raw = fs.readFileSync(filePath, 'utf-8');
-    let doc;
-    try {
-        doc = JSON.parse(raw);
-    }
-    catch {
-        return {
-            ok: false,
-            errors: [{ code: 'PRAD-E001', severity: 'error', path: filePath, message: 'Invalid JSON' }],
-            warnings: [],
-        };
-    }
-    return checkPradDocument(doc, options);
-}

package/dist/prad/check.test.js

@@ -1,27 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { describe, expect, it } from 'vitest';
-import { checkPradFile } from './check.js';
-import { explainPradPath, formatExplain } from './explain.js';
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const mahjongSample = path.resolve(__dirname, '..', '..', '..', '..', 'docs', 'prad', 'samples', 'mahjong-gate4.atom-tree.json');
-describe('prad check', () => {
-    it('mahjong gate4 v0.2 passes with warnings for draft atoms', () => {
-        if (!fs.existsSync(mahjongSample))
-            return;
-        const result = checkPradFile(mahjongSample, { gate: 4 });
-        expect(result.errors).toEqual([]);
-        expect(result.warnings.some((w) => w.code === 'PRAD-W020')).toBe(true);
-        expect(result.ok).toBe(true);
-    });
-    it('explain play_btn path', () => {
-        if (!fs.existsSync(mahjongSample))
-            return;
-        const doc = JSON.parse(fs.readFileSync(mahjongSample, 'utf-8'));
-        const result = explainPradPath(doc, 'scenes.entry.ui_layer.play_btn');
-        expect(result.found).toBe(true);
-        expect(result.slot?.spine).toBe('medium.hook.play');
-        expect(formatExplain(result)).toContain('medium.hook.play');
-    });
-});

package/dist/prad/explain.js

@@ -1,109 +0,0 @@
-import { parseAtomRef } from './atom-ref.js';
-import { loadSpineRegistry } from './load-spec.js';
-import { resolvePath } from './paths.js';
-import { effectiveAtomId, loadManifestImports, loadRegistryAtomIds } from './skills-index.js';
-export function explainPradPath(doc, logicalPath, options = {}) {
-    const visit = resolvePath(doc, logicalPath);
-    if (!visit) {
-        return { path: logicalPath, found: false };
-    }
-    const registry = loadRegistryAtomIds(options.skillsDir);
-    const spineReg = loadSpineRegistry(options.specDir);
-    const result = { path: logicalPath, found: true, kind: visit.kind };
-    if (visit.kind === 'entity' && visit.entity) {
-        const atom = parseAtomRef(visit.entity.atom);
-        result.atom = atom ?? undefined;
-        result.effectiveAtomId = atom ? effectiveAtomId(atom) : undefined;
-        result.registryHit = atom ? registry.has(atom.id) : undefined;
-        if (atom?.resolve === 'draft' && atom.substitute) {
-            result.registryHit = registry.has(atom.substitute);
-        }
-        result.slot = visit.entity.slot;
-        result.sinceGate = visit.entity.sinceGate;
-        const spineId = visit.entity.slot?.spine;
-        if (spineId && spineReg.spines[spineId]) {
-            result.spineDescription = spineReg.spines[spineId].description;
-        }
-        const props = visit.entity.props;
-        if (props) {
-            const refs = [];
-            for (const [k, v] of Object.entries(props)) {
-                if (v && typeof v === 'object' && 'ref' in v)
-                    refs.push(`${k} → ${v.ref}`);
-                if (typeof v === 'string' && k.endsWith('Ref'))
-                    refs.push(`${k} → ${v}`);
-                if (k === 'binding' && typeof v === 'string')
-                    refs.push(`binding → ${v}`);
-            }
-            if (refs.length)
-                result.refs = refs;
-        }
-    }
-    if (visit.kind === 'media' && visit.mediaInstance) {
-        const atom = parseAtomRef(visit.mediaInstance.atom);
-        result.atom = atom ?? undefined;
-        result.effectiveAtomId = atom ? effectiveAtomId(atom) : undefined;
-        result.bindAs = visit.mediaInstance.bindAs;
-        const bindTargetRef = visit.mediaInstance.bindTargetRef;
-        if (bindTargetRef) {
-            result.bindTargetRef = bindTargetRef;
-            const targetVisit = resolvePath(doc, bindTargetRef);
-            if (targetVisit?.entity) {
-                const targetAtom = parseAtomRef(targetVisit.entity.atom);
-                if (targetAtom) {
-                    const targetEff = effectiveAtomId(targetAtom);
-                    result.bindTargetEffectiveAtom = targetEff;
-                    const imports = loadManifestImports(targetEff, options.skillsDir);
-                    if (imports)
-                        result.manifestImportSlots = [...imports.bindAsSet];
-                }
-            }
-        }
-        else if (visit.parentEntityAtom) {
-            const parentEff = effectiveAtomId(visit.parentEntityAtom);
-            result.parentEffectiveAtom = parentEff;
-            const imports = loadManifestImports(parentEff, options.skillsDir);
-            if (imports)
-                result.manifestImportSlots = [...imports.bindAsSet];
-        }
-    }
-    if (visit.kind === 'global' && visit.mediaInstance) {
-        result.atom = parseAtomRef(visit.mediaInstance.atom) ?? undefined;
-        result.bindAs = visit.mediaInstance.bindAs;
-    }
-    return result;
-}
-export function formatExplain(result) {
-    const lines = [`path: ${result.path}`, `found: ${result.found}`];
-    if (!result.found)
-        return lines.join('\n');
-    if (result.kind)
-        lines.push(`kind: ${result.kind}`);
-    if (result.slot)
-        lines.push(`slot: ${JSON.stringify(result.slot)}`);
-    if (result.sinceGate != null)
-        lines.push(`sinceGate: ${result.sinceGate}`);
-    if (result.atom)
-        lines.push(`atom: ${JSON.stringify(result.atom)}`);
-    if (result.effectiveAtomId)
-        lines.push(`effectiveAtomId: ${result.effectiveAtomId}`);
-    if (result.registryHit != null)
-        lines.push(`registryHit: ${result.registryHit}`);
-    if (result.spineDescription) {
-        lines.push(`spineDescription: ${result.spineDescription.zh ?? result.spineDescription.en ?? ''}`);
-    }
-    if (result.bindAs)
-        lines.push(`bindAs: ${result.bindAs}`);
-    if (result.bindTargetRef)
-        lines.push(`bindTargetRef: ${result.bindTargetRef}`);
-    if (result.parentEffectiveAtom)
-        lines.push(`parentEffectiveAtom: ${result.parentEffectiveAtom}`);
-    if (result.bindTargetEffectiveAtom)
-        lines.push(`bindTargetEffectiveAtom: ${result.bindTargetEffectiveAtom}`);
-    if (result.manifestImportSlots?.length) {
-        lines.push(`manifestImportSlots: ${result.manifestImportSlots.join(', ')}`);
-    }
-    if (result.refs?.length)
-        lines.push(`refs:\n  ${result.refs.join('\n  ')}`);
-    return lines.join('\n');
-}

package/dist/prad/load-spec.js

@@ -1,23 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { fileURLToPath } from 'node:url';
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-export function resolvePradSpecDir(customDir) {
-    if (customDir)
-        return path.resolve(customDir);
-    const mono = path.resolve(__dirname, '..', '..', '..', '..', 'docs', 'prad', 'spec');
-    if (fs.existsSync(path.join(mono, 'spine-registry.v1.json')))
-        return mono;
-    const cwd = path.join(process.cwd(), 'docs', 'prad', 'spec');
-    if (fs.existsSync(path.join(cwd, 'spine-registry.v1.json')))
-        return cwd;
-    return mono;
-}
-export function loadSpineRegistry(specDir) {
-    const file = path.join(resolvePradSpecDir(specDir), 'spine-registry.v1.json');
-    return JSON.parse(fs.readFileSync(file, 'utf-8'));
-}
-export function loadGateRequirements(specDir) {
-    const file = path.join(resolvePradSpecDir(specDir), 'gate-requirements.v1.json');
-    return JSON.parse(fs.readFileSync(file, 'utf-8'));
-}