marlarky 1.0.0

package/dist/lexicon/store.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Lexicon Store Implementation
+ * Provides access to lexicon data and sampling utilities
+ */
+import type { ILexiconStore } from '../interfaces/lexicon-store.js';
+import type { IRng } from '../interfaces/rng.js';
+import type { GenerationContext } from '../types/context.js';
+import type { Lexicon, TermSet, Pattern, LexicalItem, TermQuery, PatternQuery, ChoiceEvent, RelationResult, Archetype, DistributionEntry, POS } from '../types/lexicon.js';
+export declare class LexiconStore implements ILexiconStore {
+    private lexicon;
+    private rng;
+    constructor(rng: IRng, lexicon?: Lexicon);
+    setLexicon(lexicon: Lexicon): void;
+    isLoaded(): boolean;
+    getMeta(): {
+        id: string;
+        version?: string;
+        language: string;
+    } | undefined;
+    getTermSet(id: string): TermSet | undefined;
+    getTermSetIds(): string[];
+    sampleTerm(termQuery: TermQuery, ctx: GenerationContext): LexicalItem | undefined;
+    private findMatchingTermSets;
+    getPattern(id: string): Pattern | undefined;
+    getPatternIds(): string[];
+    samplePattern(patternQuery: PatternQuery, ctx: GenerationContext): Pattern | undefined;
+    applyCorrelations(ctx: GenerationContext, chosen: ChoiceEvent): void;
+    private matchesCorrelationCondition;
+    evaluateRelations(entityOrTerm: string, relationType?: string): RelationResult[];
+    getArchetype(name: string): Archetype | undefined;
+    getArchetypeNames(): string[];
+    getDistribution(id: string): DistributionEntry[] | undefined;
+    /** Get all term sets matching a POS */
+    getTermSetsByPOS(pos: POS): Array<{
+        id: string;
+        set: TermSet;
+    }>;
+}
+//# sourceMappingURL=store.d.ts.map

package/dist/lexicon/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/lexicon/store.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAC;AACjD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,KAAK,EACV,OAAO,EACP,OAAO,EACP,OAAO,EACP,WAAW,EACX,SAAS,EACT,YAAY,EACZ,WAAW,EACX,cAAc,EACd,SAAS,EACT,iBAAiB,EACjB,GAAG,EACJ,MAAM,qBAAqB,CAAC;AAE7B,qBAAa,YAAa,YAAW,aAAa;IAChD,OAAO,CAAC,OAAO,CAAwB;IACvC,OAAO,CAAC,GAAG,CAAO;gBAEN,GAAG,EAAE,IAAI,EAAE,OAAO,CAAC,EAAE,OAAO;IAOxC,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAIlC,QAAQ,IAAI,OAAO;IAInB,OAAO,IAAI;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS;IASzE,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;IAI3C,aAAa,IAAI,MAAM,EAAE;IAKzB,UAAU,CAAC,SAAS,EAAE,SAAS,EAAE,GAAG,EAAE,iBAAiB,GAAG,WAAW,GAAG,SAAS;IAwEjF,OAAO,CAAC,oBAAoB;IA4C5B,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;IAI3C,aAAa,IAAI,MAAM,EAAE;IAKzB,aAAa,CAAC,YAAY,EAAE,YAAY,EAAE,GAAG,EAAE,iBAAiB,GAAG,OAAO,GAAG,SAAS;IAgDtF,iBAAiB,CAAC,GAAG,EAAE,iBAAiB,EAAE,MAAM,EAAE,WAAW,GAAG,IAAI;IAiCpE,OAAO,CAAC,2BAA2B;IA0BnC,iBAAiB,CAAC,YAAY,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,cAAc,EAAE;IAkChF,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS;IAIjD,iBAAiB,IAAI,MAAM,EAAE;IAK7B,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,iBAAiB,EAAE,GAAG,SAAS;IAI5D,uCAAuC;IACvC,gBAAgB,CAAC,GAAG,EAAE,GAAG,GAAG,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,OAAO,CAAA;KAAE,CAAC;CAWhE"}

package/dist/lexicon/store.js

@@ -0,0 +1,291 @@
+/**
+ * Lexicon Store Implementation
+ * Provides access to lexicon data and sampling utilities
+ */
+export class LexiconStore {
+    lexicon = null;
+    rng;
+    constructor(rng, lexicon) {
+        this.rng = rng;
+        if (lexicon) {
+            this.lexicon = lexicon;
+        }
+    }
+    setLexicon(lexicon) {
+        this.lexicon = lexicon;
+    }
+    isLoaded() {
+        return this.lexicon !== null;
+    }
+    getMeta() {
+        if (!this.lexicon)
+            return undefined;
+        return {
+            id: this.lexicon.id,
+            version: this.lexicon.version,
+            language: this.lexicon.language,
+        };
+    }
+    getTermSet(id) {
+        return this.lexicon?.termSets?.[id];
+    }
+    getTermSetIds() {
+        if (!this.lexicon?.termSets)
+            return [];
+        return Object.keys(this.lexicon.termSets);
+    }
+    sampleTerm(termQuery, ctx) {
+        if (!this.lexicon?.termSets)
+            return undefined;
+        // Find matching term sets
+        const candidateSets = this.findMatchingTermSets(termQuery, ctx);
+        if (candidateSets.length === 0)
+            return undefined;
+        // Weight the term sets based on distributions and biases
+        const weightedSets = candidateSets.map(({ id, set }) => {
+            let weight = 1;
+            // Apply distribution weights from archetype
+            const archetype = this.getArchetype(ctx.archetype);
+            if (archetype?.distributions?.termSetBias) {
+                const dist = this.getDistribution(archetype.distributions.termSetBias);
+                const entry = dist?.find(e => e.key === id);
+                if (entry) {
+                    weight *= entry.weight;
+                }
+            }
+            // Apply context biases
+            const bias = ctx.biases.get(id) ?? 0;
+            weight += bias;
+            return { item: { id, set }, weight: Math.max(0, weight) };
+        });
+        // Sample a term set
+        const validWeightedSets = weightedSets.filter(w => w.weight > 0);
+        if (validWeightedSets.length === 0)
+            return undefined;
+        const { id: termSetId, set } = this.rng.weightedPick(validWeightedSets);
+        // Filter terms by features and exclusions
+        let terms = set.terms.filter(t => {
+            // Check features match
+            if (termQuery.features) {
+                for (const [key, value] of Object.entries(termQuery.features)) {
+                    if (t.features?.[key] !== value) {
+                        return false;
+                    }
+                }
+            }
+            // Check exclusions
+            if (termQuery.exclude?.includes(t.value)) {
+                return false;
+            }
+            return true;
+        });
+        if (terms.length === 0)
+            return undefined;
+        // Weight and sample a term
+        const weightedTerms = terms.map(t => ({
+            item: t,
+            weight: t.weight ?? 1,
+        }));
+        const term = this.rng.weightedPick(weightedTerms);
+        return {
+            value: term.value,
+            pos: termQuery.pos,
+            termSetId,
+            features: term.features,
+            tags: term.tags ?? set.tags,
+        };
+    }
+    findMatchingTermSets(termQuery, ctx) {
+        if (!this.lexicon?.termSets)
+            return [];
+        const results = [];
+        // If explicit IDs provided, use only those
+        if (termQuery.termSetIds && termQuery.termSetIds.length > 0) {
+            for (const id of termQuery.termSetIds) {
+                const set = this.lexicon.termSets[id];
+                if (set && set.pos === termQuery.pos) {
+                    results.push({ id, set });
+                }
+            }
+            return results;
+        }
+        // Otherwise find by POS and tags
+        for (const [id, set] of Object.entries(this.lexicon.termSets)) {
+            // Must match POS
+            if (set.pos !== termQuery.pos)
+                continue;
+            // Check tags
+            if (termQuery.tags && termQuery.tags.length > 0) {
+                const setTags = new Set(set.tags ?? []);
+                const hasMatchingTag = termQuery.tags.some(t => setTags.has(t));
+                if (!hasMatchingTag)
+                    continue;
+            }
+            // Check context active tags
+            if (ctx.activeTags.size > 0 && set.tags) {
+                const setTags = new Set(set.tags);
+                const hasActiveTag = [...ctx.activeTags].some(t => setTags.has(t));
+                // Boost sets that match active tags (but don't exclude non-matching)
+                if (!hasActiveTag && termQuery.tags && termQuery.tags.length > 0) {
+                    continue; // Only exclude if specific tags were requested
+                }
+            }
+            results.push({ id, set });
+        }
+        return results;
+    }
+    getPattern(id) {
+        return this.lexicon?.patterns?.[id];
+    }
+    getPatternIds() {
+        if (!this.lexicon?.patterns)
+            return [];
+        return Object.keys(this.lexicon.patterns);
+    }
+    samplePattern(patternQuery, ctx) {
+        if (!this.lexicon?.patterns)
+            return undefined;
+        // Find matching patterns
+        const candidates = [];
+        // If explicit IDs provided
+        if (patternQuery.patternIds && patternQuery.patternIds.length > 0) {
+            for (const id of patternQuery.patternIds) {
+                const pattern = this.lexicon.patterns[id];
+                if (pattern && pattern.type === patternQuery.type) {
+                    candidates.push({ id, pattern });
+                }
+            }
+        }
+        else {
+            // Find by type and tags
+            for (const [id, pattern] of Object.entries(this.lexicon.patterns)) {
+                if (pattern.type !== patternQuery.type)
+                    continue;
+                if (patternQuery.tags && patternQuery.tags.length > 0) {
+                    const patternTags = new Set(pattern.tags ?? []);
+                    const hasTag = patternQuery.tags.some(t => patternTags.has(t));
+                    if (!hasTag)
+                        continue;
+                }
+                candidates.push({ id, pattern });
+            }
+        }
+        if (candidates.length === 0)
+            return undefined;
+        // Weight patterns
+        const weighted = candidates.map(({ id, pattern }) => {
+            let weight = pattern.weight ?? 1;
+            // Apply context biases
+            const bias = ctx.biases.get(`pattern:${id}`) ?? 0;
+            weight += bias;
+            return { item: pattern, weight: Math.max(0, weight) };
+        });
+        const validWeighted = weighted.filter(w => w.weight > 0);
+        if (validWeighted.length === 0)
+            return undefined;
+        return this.rng.weightedPick(validWeighted);
+    }
+    applyCorrelations(ctx, chosen) {
+        if (!this.lexicon?.correlations)
+            return;
+        for (const correlation of this.lexicon.correlations) {
+            // Check if condition matches
+            if (!this.matchesCorrelationCondition(correlation.when, chosen)) {
+                continue;
+            }
+            // Apply boosts
+            for (const boost of correlation.thenBoost) {
+                const scope = correlation.scope;
+                const prefix = `${scope}:`;
+                if (boost.termSet) {
+                    const key = prefix + boost.termSet;
+                    const current = ctx.biases.get(key) ?? 0;
+                    ctx.biases.set(key, current + boost.weightDelta);
+                    // Also set without prefix for simpler lookup
+                    const currentSimple = ctx.biases.get(boost.termSet) ?? 0;
+                    ctx.biases.set(boost.termSet, currentSimple + boost.weightDelta);
+                }
+                if (boost.pattern) {
+                    const key = prefix + `pattern:${boost.pattern}`;
+                    const current = ctx.biases.get(key) ?? 0;
+                    ctx.biases.set(key, current + boost.weightDelta);
+                }
+            }
+        }
+    }
+    matchesCorrelationCondition(condition, chosen) {
+        if (condition.chosenTermSet && chosen.termSetId === condition.chosenTermSet) {
+            return true;
+        }
+        if (condition.chosenTag && chosen.type === 'term') {
+            const item = chosen.item;
+            if (item.tags?.includes(condition.chosenTag)) {
+                return true;
+            }
+        }
+        if (condition.chosenValue && chosen.type === 'term') {
+            const item = chosen.item;
+            if (item.value === condition.chosenValue) {
+                return true;
+            }
+        }
+        if (condition.usedPattern && chosen.patternId === condition.usedPattern) {
+            return true;
+        }
+        return false;
+    }
+    evaluateRelations(entityOrTerm, relationType) {
+        if (!this.lexicon?.relations)
+            return [];
+        const results = [];
+        for (const relation of this.lexicon.relations) {
+            // Check outgoing relations
+            if (relation.from === entityOrTerm) {
+                if (!relationType || relation.type === relationType) {
+                    results.push({
+                        term: relation.to,
+                        relationType: relation.type,
+                        weight: relation.weight ?? 1,
+                        direction: 'outgoing',
+                    });
+                }
+            }
+            // Check incoming relations
+            if (relation.to === entityOrTerm) {
+                if (!relationType || relation.type === relationType) {
+                    results.push({
+                        term: relation.from,
+                        relationType: relation.type,
+                        weight: relation.weight ?? 1,
+                        direction: 'incoming',
+                    });
+                }
+            }
+        }
+        return results;
+    }
+    getArchetype(name) {
+        return this.lexicon?.archetypes?.[name];
+    }
+    getArchetypeNames() {
+        if (!this.lexicon?.archetypes)
+            return [];
+        return Object.keys(this.lexicon.archetypes);
+    }
+    getDistribution(id) {
+        return this.lexicon?.distributions?.[id];
+    }
+    /** Get all term sets matching a POS */
+    getTermSetsByPOS(pos) {
+        if (!this.lexicon?.termSets)
+            return [];
+        const results = [];
+        for (const [id, set] of Object.entries(this.lexicon.termSets)) {
+            if (set.pos === pos) {
+                results.push({ id, set });
+            }
+        }
+        return results;
+    }
+}
+//# sourceMappingURL=store.js.map

package/dist/lexicon/store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.js","sourceRoot":"","sources":["../../src/lexicon/store.ts"],"names":[],"mappings":"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"}

package/dist/lexicon/validator.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Lexicon Validator
+ * Validates lexicon JSON structure and returns structured errors
+ */
+import type { LexiconValidationResult } from '../types/api.js';
+/**
+ * Validate a lexicon object
+ */
+export declare function validateLexicon(lexicon: unknown): LexiconValidationResult;
+//# sourceMappingURL=validator.d.ts.map

package/dist/lexicon/validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.d.ts","sourceRoot":"","sources":["../../src/lexicon/validator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,uBAAuB,EAA0B,MAAM,iBAAiB,CAAC;AAQvF;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,uBAAuB,CAsEzE"}

package/dist/lexicon/validator.js

@@ -0,0 +1,273 @@
+/**
+ * Lexicon Validator
+ * Validates lexicon JSON structure and returns structured errors
+ */
+const VALID_POS = ['noun', 'verb', 'adj', 'adv', 'prep', 'conj', 'intj', 'det'];
+const VALID_SCOPES = ['token', 'phrase', 'clause', 'sentence', 'paragraph', 'text'];
+const VALID_CONSTRAINT_TYPES = ['noRepeat', 'maxCount', 'minCount', 'required', 'forbidden', 'custom'];
+const VALID_INVARIANT_TYPES = ['capitalization', 'punctuation', 'whitespace', 'agreement', 'custom'];
+const VALID_PATTERN_TYPES = ['sentence', 'nounPhrase', 'verbPhrase', 'prepPhrase', 'adjPhrase', 'advPhrase', 'clause'];
+/**
+ * Validate a lexicon object
+ */
+export function validateLexicon(lexicon) {
+    const errors = [];
+    const warnings = [];
+    if (!lexicon || typeof lexicon !== 'object') {
+        errors.push({ path: '', message: 'Lexicon must be an object', severity: 'error' });
+        return { valid: false, errors, warnings };
+    }
+    const lex = lexicon;
+    // Required fields
+    if (typeof lex.id !== 'string' || lex.id.trim() === '') {
+        errors.push({ path: 'id', message: 'Lexicon must have a non-empty string "id"', severity: 'error' });
+    }
+    if (typeof lex.language !== 'string' || lex.language.trim() === '') {
+        errors.push({ path: 'language', message: 'Lexicon must have a non-empty string "language"', severity: 'error' });
+    }
+    // Optional version
+    if (lex.version !== undefined && typeof lex.version !== 'string') {
+        warnings.push({ path: 'version', message: 'Version should be a string', severity: 'warning' });
+    }
+    // Validate termSets
+    if (lex.termSets !== undefined) {
+        validateTermSets(lex.termSets, errors, warnings);
+    }
+    // Validate patterns
+    if (lex.patterns !== undefined) {
+        validatePatterns(lex.patterns, errors, warnings);
+    }
+    // Validate distributions
+    if (lex.distributions !== undefined) {
+        validateDistributions(lex.distributions, errors, warnings);
+    }
+    // Validate correlations
+    if (lex.correlations !== undefined) {
+        validateCorrelations(lex.correlations, errors, warnings);
+    }
+    // Validate constraints
+    if (lex.constraints !== undefined) {
+        validateConstraints(lex.constraints, errors, warnings);
+    }
+    // Validate invariants
+    if (lex.invariants !== undefined) {
+        validateInvariants(lex.invariants, errors, warnings);
+    }
+    // Validate archetypes
+    if (lex.archetypes !== undefined) {
+        validateArchetypes(lex.archetypes, errors, warnings);
+    }
+    // Validate relations
+    if (lex.relations !== undefined) {
+        validateRelations(lex.relations, errors, warnings);
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+function validateTermSets(termSets, errors, warnings) {
+    if (typeof termSets !== 'object' || termSets === null) {
+        errors.push({ path: 'termSets', message: 'termSets must be an object', severity: 'error' });
+        return;
+    }
+    for (const [id, termSet] of Object.entries(termSets)) {
+        const path = `termSets.${id}`;
+        if (typeof termSet !== 'object' || termSet === null) {
+            errors.push({ path, message: 'Term set must be an object', severity: 'error' });
+            continue;
+        }
+        const ts = termSet;
+        if (!VALID_POS.includes(ts.pos)) {
+            errors.push({ path: `${path}.pos`, message: `Invalid POS: ${ts.pos}. Must be one of: ${VALID_POS.join(', ')}`, severity: 'error' });
+        }
+        if (ts.tags !== undefined && !Array.isArray(ts.tags)) {
+            warnings.push({ path: `${path}.tags`, message: 'tags should be an array', severity: 'warning' });
+        }
+        if (!Array.isArray(ts.terms)) {
+            errors.push({ path: `${path}.terms`, message: 'terms must be an array', severity: 'error' });
+        }
+        else {
+            ts.terms.forEach((term, index) => {
+                validateTerm(term, `${path}.terms[${index}]`, errors, warnings);
+            });
+        }
+    }
+}
+function validateTerm(term, path, errors, warnings) {
+    if (typeof term !== 'object' || term === null) {
+        errors.push({ path, message: 'Term must be an object', severity: 'error' });
+        return;
+    }
+    const t = term;
+    if (typeof t.value !== 'string' || t.value.trim() === '') {
+        errors.push({ path: `${path}.value`, message: 'Term must have a non-empty string "value"', severity: 'error' });
+    }
+    if (t.weight !== undefined && (typeof t.weight !== 'number' || t.weight < 0)) {
+        warnings.push({ path: `${path}.weight`, message: 'weight should be a non-negative number', severity: 'warning' });
+    }
+    if (t.tags !== undefined && !Array.isArray(t.tags)) {
+        warnings.push({ path: `${path}.tags`, message: 'tags should be an array', severity: 'warning' });
+    }
+}
+function validatePatterns(patterns, errors, _warnings) {
+    if (typeof patterns !== 'object' || patterns === null) {
+        errors.push({ path: 'patterns', message: 'patterns must be an object', severity: 'error' });
+        return;
+    }
+    for (const [id, pattern] of Object.entries(patterns)) {
+        const path = `patterns.${id}`;
+        if (typeof pattern !== 'object' || pattern === null) {
+            errors.push({ path, message: 'Pattern must be an object', severity: 'error' });
+            continue;
+        }
+        const p = pattern;
+        if (!VALID_PATTERN_TYPES.includes(p.type)) {
+            errors.push({ path: `${path}.type`, message: `Invalid pattern type: ${p.type}`, severity: 'error' });
+        }
+        if (!Array.isArray(p.slots)) {
+            errors.push({ path: `${path}.slots`, message: 'slots must be an array', severity: 'error' });
+        }
+    }
+}
+function validateDistributions(distributions, errors, warnings) {
+    if (typeof distributions !== 'object' || distributions === null) {
+        errors.push({ path: 'distributions', message: 'distributions must be an object', severity: 'error' });
+        return;
+    }
+    for (const [id, dist] of Object.entries(distributions)) {
+        const path = `distributions.${id}`;
+        if (!Array.isArray(dist)) {
+            errors.push({ path, message: 'Distribution must be an array', severity: 'error' });
+            continue;
+        }
+        dist.forEach((entry, index) => {
+            if (typeof entry !== 'object' || entry === null) {
+                errors.push({ path: `${path}[${index}]`, message: 'Distribution entry must be an object', severity: 'error' });
+                return;
+            }
+            const e = entry;
+            if (typeof e.key !== 'string') {
+                errors.push({ path: `${path}[${index}].key`, message: 'key must be a string', severity: 'error' });
+            }
+            if (typeof e.weight !== 'number' || e.weight < 0) {
+                warnings.push({ path: `${path}[${index}].weight`, message: 'weight should be a non-negative number', severity: 'warning' });
+            }
+        });
+    }
+}
+function validateCorrelations(correlations, errors, warnings) {
+    if (!Array.isArray(correlations)) {
+        errors.push({ path: 'correlations', message: 'correlations must be an array', severity: 'error' });
+        return;
+    }
+    correlations.forEach((corr, index) => {
+        const path = `correlations[${index}]`;
+        if (typeof corr !== 'object' || corr === null) {
+            errors.push({ path, message: 'Correlation must be an object', severity: 'error' });
+            return;
+        }
+        const c = corr;
+        if (typeof c.when !== 'object' || c.when === null) {
+            errors.push({ path: `${path}.when`, message: 'when must be an object', severity: 'error' });
+        }
+        if (!Array.isArray(c.thenBoost)) {
+            errors.push({ path: `${path}.thenBoost`, message: 'thenBoost must be an array', severity: 'error' });
+        }
+        if (!VALID_SCOPES.includes(c.scope)) {
+            warnings.push({ path: `${path}.scope`, message: `Invalid scope: ${c.scope}`, severity: 'warning' });
+        }
+    });
+}
+function validateConstraints(constraints, errors, _warnings) {
+    if (!Array.isArray(constraints)) {
+        errors.push({ path: 'constraints', message: 'constraints must be an array', severity: 'error' });
+        return;
+    }
+    constraints.forEach((constraint, index) => {
+        const path = `constraints[${index}]`;
+        if (typeof constraint !== 'object' || constraint === null) {
+            errors.push({ path, message: 'Constraint must be an object', severity: 'error' });
+            return;
+        }
+        const c = constraint;
+        if (typeof c.id !== 'string') {
+            errors.push({ path: `${path}.id`, message: 'id must be a string', severity: 'error' });
+        }
+        if (c.level !== 'hard' && c.level !== 'soft') {
+            errors.push({ path: `${path}.level`, message: 'level must be "hard" or "soft"', severity: 'error' });
+        }
+        if (!VALID_SCOPES.includes(c.scope)) {
+            errors.push({ path: `${path}.scope`, message: `Invalid scope: ${c.scope}`, severity: 'error' });
+        }
+        if (!VALID_CONSTRAINT_TYPES.includes(c.type)) {
+            errors.push({ path: `${path}.type`, message: `Invalid constraint type: ${c.type}`, severity: 'error' });
+        }
+        if (typeof c.target !== 'string') {
+            errors.push({ path: `${path}.target`, message: 'target must be a string', severity: 'error' });
+        }
+    });
+}
+function validateInvariants(invariants, errors, _warnings) {
+    if (!Array.isArray(invariants)) {
+        errors.push({ path: 'invariants', message: 'invariants must be an array', severity: 'error' });
+        return;
+    }
+    invariants.forEach((invariant, index) => {
+        const path = `invariants[${index}]`;
+        if (typeof invariant !== 'object' || invariant === null) {
+            errors.push({ path, message: 'Invariant must be an object', severity: 'error' });
+            return;
+        }
+        const inv = invariant;
+        if (typeof inv.id !== 'string') {
+            errors.push({ path: `${path}.id`, message: 'id must be a string', severity: 'error' });
+        }
+        if (!VALID_INVARIANT_TYPES.includes(inv.type)) {
+            errors.push({ path: `${path}.type`, message: `Invalid invariant type: ${inv.type}`, severity: 'error' });
+        }
+        if (!VALID_SCOPES.includes(inv.scope)) {
+            errors.push({ path: `${path}.scope`, message: `Invalid scope: ${inv.scope}`, severity: 'error' });
+        }
+    });
+}
+function validateArchetypes(archetypes, errors, _warnings) {
+    if (typeof archetypes !== 'object' || archetypes === null) {
+        errors.push({ path: 'archetypes', message: 'archetypes must be an object', severity: 'error' });
+        return;
+    }
+    for (const [id, archetype] of Object.entries(archetypes)) {
+        const path = `archetypes.${id}`;
+        if (typeof archetype !== 'object' || archetype === null) {
+            errors.push({ path, message: 'Archetype must be an object', severity: 'error' });
+        }
+    }
+}
+function validateRelations(relations, errors, warnings) {
+    if (!Array.isArray(relations)) {
+        errors.push({ path: 'relations', message: 'relations must be an array', severity: 'error' });
+        return;
+    }
+    relations.forEach((relation, index) => {
+        const path = `relations[${index}]`;
+        if (typeof relation !== 'object' || relation === null) {
+            errors.push({ path, message: 'Relation must be an object', severity: 'error' });
+            return;
+        }
+        const r = relation;
+        if (typeof r.from !== 'string') {
+            errors.push({ path: `${path}.from`, message: 'from must be a string', severity: 'error' });
+        }
+        if (typeof r.type !== 'string') {
+            errors.push({ path: `${path}.type`, message: 'type must be a string', severity: 'error' });
+        }
+        if (typeof r.to !== 'string') {
+            errors.push({ path: `${path}.to`, message: 'to must be a string', severity: 'error' });
+        }
+        if (r.weight !== undefined && (typeof r.weight !== 'number' || r.weight < 0)) {
+            warnings.push({ path: `${path}.weight`, message: 'weight should be a non-negative number', severity: 'warning' });
+        }
+    });
+}
+//# sourceMappingURL=validator.js.map