@playcraft/cli 0.0.42 → 0.0.43

package/dist/prad/check.js

@@ -0,0 +1,377 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,109 @@
+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

@@ -0,0 +1,23 @@
+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'));
+}

package/dist/prad/paths.js

@@ -0,0 +1,83 @@
+import { parseAtomRef } from './atom-ref.js';
+function visitEntities(basePath, entities, out, parentEntityAtom) {
+    if (!Array.isArray(entities))
+        return;
+    for (const raw of entities) {
+        if (!raw || typeof raw !== 'object')
+            continue;
+        const entity = raw;
+        const id = entity.id;
+        if (typeof id !== 'string')
+            continue;
+        const entityPath = `${basePath}.${id}`;
+        const atomRef = parseAtomRef(entity.atom);
+        out.push({ path: entityPath, kind: 'entity', entity, parentEntityAtom });
+        const props = entity.props;
+        if (props && typeof props === 'object') {
+            for (const [key, val] of Object.entries(props)) {
+                if (val && typeof val === 'object' && 'atom' in val) {
+                    out.push({
+                        path: `${entityPath}.props.${key}`,
+                        kind: 'media',
+                        entity,
+                        parentEntityAtom: atomRef ?? undefined,
+                        mediaPropKey: key,
+                        mediaInstance: val,
+                    });
+                }
+            }
+        }
+        if (Array.isArray(entity.children)) {
+            visitEntities(entityPath, entity.children, out, atomRef ?? undefined);
+        }
+    }
+}
+export function walkPradDocument(doc) {
+    const out = [];
+    const globals = doc.globals;
+    if (globals && typeof globals === 'object') {
+        for (const [key, val] of Object.entries(globals)) {
+            if (val && typeof val === 'object' && 'atom' in val) {
+                out.push({
+                    path: `globals.${key}`,
+                    kind: 'global',
+                    globalKey: key,
+                    mediaInstance: val,
+                });
+            }
+        }
+    }
+    const scenes = doc.scenes;
+    if (Array.isArray(scenes)) {
+        for (const scene of scenes) {
+            if (!scene || typeof scene !== 'object')
+                continue;
+            const sceneId = scene.id;
+            if (typeof sceneId !== 'string')
+                continue;
+            const layers = scene.layers;
+            if (!Array.isArray(layers))
+                continue;
+            for (const layer of layers) {
+                if (!layer || typeof layer !== 'object')
+                    continue;
+                const layerId = layer.id;
+                if (typeof layerId !== 'string')
+                    continue;
+                const base = `scenes.${sceneId}.${layerId}`;
+                visitEntities(base, layer.entities ?? [], out);
+            }
+        }
+    }
+    return out;
+}
+export function resolvePath(doc, logicalPath) {
+    return walkPradDocument(doc).find((v) => v.path === logicalPath);
+}
+/** Media path `scenes.x.y.z.props.key` → entity path `scenes.x.y.z` */
+export function parentEntityPath(mediaPath) {
+    const idx = mediaPath.lastIndexOf('.props.');
+    if (idx === -1)
+        return undefined;
+    return mediaPath.slice(0, idx);
+}

package/dist/prad/skills-index.js

@@ -0,0 +1,60 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { resolveSkillsDirs } from '../atom-plan/validate-atom-plan.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+function allSkillsDirs(customDir) {
+    const dirs = resolveSkillsDirs(customDir);
+    const monoFromPrad = path.resolve(__dirname, '..', '..', '..', 'skills', 'skills');
+    if (fs.existsSync(monoFromPrad))
+        dirs.push(monoFromPrad);
+    return [...new Set(dirs)];
+}
+/** Load set of registry atom ids from Skills directories. */
+export function loadRegistryAtomIds(skillsDir) {
+    const ids = new Set();
+    for (const dir of allSkillsDirs(skillsDir)) {
+        if (!fs.existsSync(dir))
+            continue;
+        for (const name of fs.readdirSync(dir)) {
+            const manifestPath = path.join(dir, name, 'manifest.json');
+            if (!fs.existsSync(manifestPath))
+                continue;
+            try {
+                const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+                if (manifest.atomId)
+                    ids.add(manifest.atomId);
+            }
+            catch {
+                // skip invalid manifest
+            }
+        }
+    }
+    return ids;
+}
+export function loadManifestImports(atomId, skillsDir) {
+    for (const dir of allSkillsDirs(skillsDir)) {
+        const manifestPath = path.join(dir, atomId, 'manifest.json');
+        if (!fs.existsSync(manifestPath))
+            continue;
+        try {
+            const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+            const bindAsSet = new Set();
+            for (const imp of manifest.imports ?? []) {
+                if (imp.bindAs)
+                    bindAsSet.add(imp.bindAs);
+            }
+            return { atomId: manifest.atomId ?? atomId, bindAsSet };
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+/** Effective atom id for compile: draft uses substitute when present. */
+export function effectiveAtomId(ref) {
+    if (ref.resolve === 'draft' && ref.substitute)
+        return ref.substitute;
+    return ref.id;
+}