marlarky 1.0.0

package/dist/defaults/word-lists.js

@@ -0,0 +1,124 @@
+/**
+ * Default Curated Word Lists
+ * Used when no lexicon is provided or as fallback
+ */
+// Common nouns (countable)
+export const DEFAULT_NOUNS = [
+    'idea', 'system', 'problem', 'question', 'answer', 'plan', 'reason', 'result',
+    'group', 'project', 'team', 'process', 'change', 'way', 'part', 'place',
+    'case', 'point', 'fact', 'example', 'issue', 'matter', 'thing', 'situation',
+    'area', 'level', 'type', 'kind', 'form', 'method', 'approach', 'solution',
+    'person', 'company', 'organization', 'market', 'industry', 'service', 'product',
+    'customer', 'client', 'user', 'employee', 'manager', 'leader', 'expert',
+    'report', 'document', 'policy', 'strategy', 'goal', 'objective', 'target',
+    'decision', 'action', 'step', 'task', 'activity', 'event', 'meeting',
+    'resource', 'tool', 'technology', 'data', 'information', 'knowledge', 'skill',
+    'opportunity', 'challenge', 'risk', 'benefit', 'value', 'cost', 'time',
+];
+// Common verbs (base form)
+export const DEFAULT_VERBS = [
+    'be', 'have', 'do', 'say', 'get', 'make', 'go', 'know', 'take', 'see',
+    'come', 'think', 'look', 'want', 'give', 'use', 'find', 'tell', 'ask', 'work',
+    'seem', 'feel', 'try', 'leave', 'call', 'need', 'become', 'put', 'mean', 'keep',
+    'let', 'begin', 'show', 'hear', 'play', 'run', 'move', 'live', 'believe', 'hold',
+    'bring', 'happen', 'write', 'provide', 'sit', 'stand', 'lose', 'pay', 'meet',
+    'include', 'continue', 'set', 'learn', 'change', 'lead', 'understand', 'watch',
+    'follow', 'stop', 'create', 'speak', 'read', 'spend', 'grow', 'open', 'walk',
+    'offer', 'remember', 'consider', 'appear', 'buy', 'wait', 'serve', 'send',
+    'expect', 'build', 'stay', 'fall', 'cut', 'reach', 'remain', 'suggest', 'raise',
+    'pass', 'sell', 'require', 'report', 'decide', 'support', 'develop', 'produce',
+    'achieve', 'improve', 'increase', 'reduce', 'manage', 'maintain', 'ensure',
+];
+// Common adjectives
+export const DEFAULT_ADJECTIVES = [
+    'good', 'new', 'first', 'last', 'long', 'great', 'little', 'own', 'other',
+    'old', 'right', 'big', 'high', 'different', 'small', 'large', 'next', 'early',
+    'young', 'important', 'few', 'public', 'bad', 'same', 'able', 'sure', 'real',
+    'best', 'better', 'true', 'certain', 'clear', 'full', 'special', 'free',
+    'strong', 'hard', 'likely', 'simple', 'recent', 'possible', 'whole', 'current',
+    'general', 'specific', 'available', 'significant', 'particular', 'major',
+    'successful', 'effective', 'essential', 'critical', 'key', 'primary', 'main',
+    'direct', 'positive', 'negative', 'basic', 'common', 'serious', 'difficult',
+    'similar', 'final', 'previous', 'additional', 'individual', 'professional',
+];
+// Common adverbs
+export const DEFAULT_ADVERBS = [
+    'also', 'just', 'only', 'now', 'then', 'more', 'very', 'well', 'even', 'still',
+    'already', 'often', 'always', 'never', 'really', 'much', 'most', 'almost',
+    'here', 'there', 'together', 'quite', 'soon', 'perhaps', 'probably', 'actually',
+    'simply', 'certainly', 'clearly', 'definitely', 'directly', 'easily', 'especially',
+    'eventually', 'exactly', 'finally', 'frequently', 'generally', 'greatly',
+    'highly', 'immediately', 'increasingly', 'indeed', 'naturally', 'nearly',
+    'necessarily', 'normally', 'obviously', 'particularly', 'possibly', 'primarily',
+    'quickly', 'rapidly', 'recently', 'regularly', 'significantly', 'slightly',
+    'sometimes', 'specifically', 'strongly', 'successfully', 'suddenly', 'typically',
+];
+// Common prepositions
+export const DEFAULT_PREPOSITIONS = [
+    'of', 'in', 'to', 'for', 'with', 'on', 'at', 'from', 'by', 'about',
+    'as', 'into', 'through', 'during', 'before', 'after', 'above', 'below',
+    'between', 'under', 'since', 'without', 'toward', 'upon', 'within',
+    'against', 'among', 'across', 'behind', 'beyond', 'over', 'around',
+    'throughout', 'despite', 'near', 'along', 'beside', 'outside', 'inside',
+];
+// Common conjunctions (coordinating)
+export const DEFAULT_CONJUNCTIONS = [
+    'and', 'but', 'or', 'so', 'yet', 'nor', 'for',
+];
+// Subordinating conjunctions
+export const DEFAULT_SUBORDINATORS = [
+    'after', 'although', 'as', 'because', 'before', 'if', 'once', 'since',
+    'than', 'that', 'though', 'unless', 'until', 'when', 'whenever', 'where',
+    'wherever', 'while', 'whereas',
+];
+// Common interjections
+export const DEFAULT_INTERJECTIONS = [
+    'oh', 'ah', 'well', 'wow', 'hey', 'alas', 'indeed', 'certainly', 'surely',
+    'naturally', 'clearly', 'obviously', 'honestly', 'frankly', 'fortunately',
+    'unfortunately', 'surprisingly', 'interestingly',
+];
+// Determiners
+export const DEFAULT_DETERMINERS = [
+    'the', 'a', 'an', 'this', 'that', 'these', 'those',
+    'my', 'your', 'his', 'her', 'its', 'our', 'their',
+    'some', 'any', 'no', 'every', 'each', 'all', 'both', 'few', 'many', 'several',
+    'most', 'other', 'another', 'such', 'what', 'which',
+];
+// Subject pronouns
+export const DEFAULT_SUBJECT_PRONOUNS = [
+    'I', 'you', 'he', 'she', 'it', 'we', 'they',
+];
+// Object pronouns
+export const DEFAULT_OBJECT_PRONOUNS = [
+    'me', 'you', 'him', 'her', 'it', 'us', 'them',
+];
+// Possessive determiners
+export const DEFAULT_POSSESSIVE_DETERMINERS = [
+    'my', 'your', 'his', 'her', 'its', 'our', 'their',
+];
+// Modal verbs
+export const DEFAULT_MODALS = [
+    'can', 'could', 'may', 'might', 'must', 'shall', 'should', 'will', 'would',
+];
+// Relative pronouns
+export const DEFAULT_RELATIVES = [
+    'who', 'whom', 'whose', 'which', 'that',
+];
+// Transition words/phrases
+export const DEFAULT_TRANSITIONS = [
+    'however', 'therefore', 'moreover', 'furthermore', 'meanwhile',
+    'consequently', 'nevertheless', 'otherwise', 'accordingly', 'indeed',
+    'certainly', 'naturally', 'fortunately', 'unfortunately', 'surprisingly',
+    'generally', 'specifically', 'particularly', 'additionally', 'similarly',
+    'conversely', 'alternatively', 'subsequently', 'ultimately', 'eventually',
+];
+// Question words
+export const DEFAULT_QUESTION_WORDS = [
+    'what', 'which', 'who', 'whom', 'whose', 'where', 'when', 'why', 'how',
+];
+// Auxiliary verbs
+export const DEFAULT_AUXILIARIES = [
+    'be', 'have', 'do', 'will', 'would', 'shall', 'should', 'may', 'might',
+    'can', 'could', 'must',
+];
+//# sourceMappingURL=word-lists.js.map

package/dist/defaults/word-lists.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"word-lists.js","sourceRoot":"","sources":["../../src/defaults/word-lists.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,2BAA2B;AAC3B,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ;IAC7E,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO;IACvE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,WAAW;IAC3E,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU;IACzE,QAAQ,EAAE,SAAS,EAAE,cAAc,EAAE,QAAQ,EAAE,UAAU,EAAE,SAAS,EAAE,SAAS;IAC/E,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ;IACvE,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,QAAQ;IACzE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,SAAS;IACpE,UAAU,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,aAAa,EAAE,WAAW,EAAE,OAAO;IAC7E,aAAa,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM;CACvE,CAAC;AAEF,2BAA2B;AAC3B,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK;IACrE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAC7E,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM;IAC/E,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAChF,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAC5E,SAAS,EAAE,UAAU,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,OAAO;IAC9E,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAC5E,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;IACzE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,OAAO;IAC/E,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS;IAC9E,SAAS,EAAE,SAAS,EAAE,UAAU,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ;CAC3E,CAAC;AAEF,oBAAoB;AACpB,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO;IACzE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO;IAC7E,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAC5E,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IACvE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,OAAO,EAAE,SAAS;IAC9E,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,aAAa,EAAE,YAAY,EAAE,OAAO;IACxE,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,UAAU,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM;IAC5E,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,WAAW;IAC3E,SAAS,EAAE,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,YAAY,EAAE,cAAc;CAC3E,CAAC;AAEF,iBAAiB;AACjB,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO;IAC9E,SAAS,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ;IACzE,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU;IAC/E,QAAQ,EAAE,WAAW,EAAE,SAAS,EAAE,YAAY,EAAE,UAAU,EAAE,QAAQ,EAAE,YAAY;IAClF,YAAY,EAAE,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,WAAW,EAAE,SAAS;IACxE,QAAQ,EAAE,aAAa,EAAE,cAAc,EAAE,QAAQ,EAAE,WAAW,EAAE,QAAQ;IACxE,aAAa,EAAE,UAAU,EAAE,WAAW,EAAE,cAAc,EAAE,UAAU,EAAE,WAAW;IAC/E,SAAS,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,eAAe,EAAE,UAAU;IAC1E,WAAW,EAAE,cAAc,EAAE,UAAU,EAAE,cAAc,EAAE,UAAU,EAAE,WAAW;CACjF,CAAC;AAEF,sBAAsB;AACtB,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAClC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO;IAClE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO;IACtE,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ;IAClE,SAAS,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ;IAClE,YAAY,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,QAAQ;CACxE,CAAC;AAEF,qCAAqC;AACrC,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAClC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK;CAC9C,CAAC;AAEF,6BAA6B;AAC7B,MAAM,CAAC,MAAM,qBAAqB,GAAG;IACnC,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO;IACrE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO;IACxE,UAAU,EAAE,OAAO,EAAE,SAAS;CAC/B,CAAC;AAEF,uBAAuB;AACvB,MAAM,CAAC,MAAM,qBAAqB,GAAG;IACnC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,QAAQ;IACzE,WAAW,EAAE,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,aAAa;IACzE,eAAe,EAAE,cAAc,EAAE,eAAe;CACjD,CAAC;AAEF,cAAc;AACd,MAAM,CAAC,MAAM,mBAAmB,GAAG;IACjC,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO;IAClD,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO;IACjD,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS;IAC7E,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO;CACpD,CAAC;AAEF,mBAAmB;AACnB,MAAM,CAAC,MAAM,wBAAwB,GAAG;IACtC,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM;CAC5C,CAAC;AAEF,kBAAkB;AAClB,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACrC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM;CAC9C,CAAC;AAEF,yBAAyB;AACzB,MAAM,CAAC,MAAM,8BAA8B,GAAG;IAC5C,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO;CAClD,CAAC;AAEF,cAAc;AACd,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO;CAC3E,CAAC;AAEF,oBAAoB;AACpB,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM;CACxC,CAAC;AAEF,2BAA2B;AAC3B,MAAM,CAAC,MAAM,mBAAmB,GAAG;IACjC,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,aAAa,EAAE,WAAW;IAC9D,cAAc,EAAE,cAAc,EAAE,WAAW,EAAE,aAAa,EAAE,QAAQ;IACpE,WAAW,EAAE,WAAW,EAAE,aAAa,EAAE,eAAe,EAAE,cAAc;IACxE,WAAW,EAAE,cAAc,EAAE,cAAc,EAAE,cAAc,EAAE,WAAW;IACxE,YAAY,EAAE,eAAe,EAAE,cAAc,EAAE,YAAY,EAAE,YAAY;CAC1E,CAAC;AAEF,iBAAiB;AACjB,MAAM,CAAC,MAAM,sBAAsB,GAAG;IACpC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK;CACvE,CAAC;AAEF,kBAAkB;AAClB,MAAM,CAAC,MAAM,mBAAmB,GAAG;IACjC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO;IACtE,KAAK,EAAE,OAAO,EAAE,MAAM;CACvB,CAAC"}

package/dist/generator/index.d.ts

@@ -0,0 +1,2 @@
+export { TextGenerator } from './text-generator.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/generator/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/generator/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/generator/index.js

@@ -0,0 +1,2 @@
+export { TextGenerator } from './text-generator.js';
+//# sourceMappingURL=index.js.map

package/dist/generator/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/generator/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/generator/text-generator.d.ts

@@ -0,0 +1,93 @@
+/**
+ * TextGenerator - Public API
+ * Main entry point for text generation
+ */
+import type { GeneratorInitOptions, SentenceOptions, ParagraphOptions, TextBlockOptions, GeneratedText } from '../types/api.js';
+import type { Lexicon } from '../types/lexicon.js';
+import { TransformRegistry } from '../transforms/registry.js';
+export declare class TextGenerator {
+    private config;
+    private rng;
+    private lexiconStore;
+    private wordProvider;
+    private phraseBuilders;
+    private sentenceTemplates;
+    private ruleEngine;
+    private fakerAdapter;
+    private enableTrace;
+    private currentArchetype;
+    private currentSeed;
+    private transformRegistry;
+    private currentLexicon?;
+    constructor(options: GeneratorInitOptions);
+    /**
+     * Set the random seed for deterministic output
+     */
+    setSeed(seed: number): void;
+    /**
+     * Set or replace the lexicon
+     */
+    setLexicon(lexicon: Lexicon): void;
+    /**
+     * Set the active archetype
+     */
+    setArchetype(name: string): void;
+    /**
+     * Get the transform registry (for registering custom transforms)
+     */
+    getTransformRegistry(): TransformRegistry;
+    /**
+     * Generate a single sentence
+     */
+    sentence(opts?: SentenceOptions): string | GeneratedText;
+    /**
+     * Generate a paragraph
+     */
+    paragraph(opts?: ParagraphOptions): string | GeneratedText;
+    /**
+     * Generate a text block (multiple paragraphs)
+     */
+    textBlock(opts?: TextBlockOptions): string | GeneratedText;
+    /**
+     * Apply output transforms to generated text.
+     * Merges config from: base config → lexicon defaults → archetype → per-call overrides.
+     */
+    private applyOutputTransforms;
+    /**
+     * Create a generation context
+     */
+    private createGenerationContext;
+    /**
+     * Generate a sentence with retry logic
+     */
+    private generateSentenceWithRetry;
+    /**
+     * Get active constraints (from lexicon + defaults)
+     */
+    private getActiveConstraints;
+    /**
+     * Get active invariants (from lexicon + defaults)
+     */
+    private getActiveInvariants;
+    /**
+     * Get generation metadata
+     */
+    private getMeta;
+    /**
+     * Create a trace for a single sentence result
+     */
+    private createSingleSentenceTrace;
+    /**
+     * Create a sentence trace
+     */
+    private createSentenceTrace;
+    /**
+     * Get list of correlations that were applied
+     */
+    private getAppliedCorrelations;
+    /**
+     * Check invariants on final text
+     */
+    private checkInvariants;
+}
+//# sourceMappingURL=text-generator.d.ts.map

package/dist/generator/text-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-generator.d.ts","sourceRoot":"","sources":["../../src/generator/text-generator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,oBAAoB,EACpB,eAAe,EACf,gBAAgB,EAChB,gBAAgB,EAChB,aAAa,EAKd,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,OAAO,EAAyB,MAAM,qBAAqB,CAAC;AAoB1E,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAM9D,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,GAAG,CAAO;IAClB,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,YAAY,CAAgB;IACpC,OAAO,CAAC,WAAW,CAAU;IAC7B,OAAO,CAAC,gBAAgB,CAAqB;IAC7C,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,cAAc,CAAC,CAAU;gBAErB,OAAO,EAAE,oBAAoB;IAoCzC;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAK3B;;OAEG;IACH,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAKlC;;OAEG;IACH,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAIhC;;OAEG;IACH,oBAAoB,IAAI,iBAAiB;IAIzC;;OAEG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,MAAM,GAAG,aAAa;IAoCxD;;OAEG;IACH,SAAS,CAAC,IAAI,CAAC,EAAE,gBAAgB,GAAG,MAAM,GAAG,aAAa;IAuD1D;;OAEG;IACH,SAAS,CAAC,IAAI,CAAC,EAAE,gBAAgB,GAAG,MAAM,GAAG,aAAa;IA0E1D;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAkC7B;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAyB/B;;OAEG;IACH,OAAO,CAAC,yBAAyB;IA6DjC;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAe5B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAY3B;;OAEG;IACH,OAAO,CAAC,OAAO;IAUf;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAYjC;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAoC3B;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAM9B;;OAEG;IACH,OAAO,CAAC,eAAe;CAOxB"}

package/dist/generator/text-generator.js

@@ -0,0 +1,411 @@
+/**
+ * TextGenerator - Public API
+ * Main entry point for text generation
+ */
+import { SeedableRng } from '../rng/index.js';
+import { LexiconStore } from '../lexicon/index.js';
+import { WordProvider } from '../providers/index.js';
+import { PhraseBuilders, SentenceTemplates } from '../grammar/index.js';
+import { RuleEngine } from '../rules/index.js';
+import { createContext, clearSentenceState, clearParagraphState } from '../types/context.js';
+import { mergeConfig } from '../types/config.js';
+import { formatParagraph, formatTextBlock } from '../morphology/index.js';
+import { createDefaultRegistry } from '../transforms/default-registry.js';
+import { executePipeline } from '../transforms/pipeline.js';
+import { mergeOutputTransformsConfig } from '../transforms/config-merge.js';
+export class TextGenerator {
+    config;
+    rng;
+    lexiconStore;
+    wordProvider;
+    phraseBuilders;
+    sentenceTemplates;
+    ruleEngine;
+    fakerAdapter;
+    enableTrace;
+    currentArchetype = 'default';
+    currentSeed;
+    transformRegistry;
+    currentLexicon;
+    constructor(options) {
+        this.fakerAdapter = options.fakerAdapter;
+        this.config = mergeConfig(options.config);
+        this.enableTrace = options.enableTrace ?? this.config.enableTrace;
+        // Initialize RNG
+        this.rng = options.rng ?? new SeedableRng();
+        this.currentSeed = Date.now();
+        this.rng.seed(this.currentSeed);
+        // Initialize lexicon store
+        this.lexiconStore = new LexiconStore(this.rng, options.lexicon);
+        this.currentLexicon = options.lexicon;
+        // Initialize word provider
+        this.wordProvider = new WordProvider(this.lexiconStore, this.fakerAdapter, this.rng);
+        // Initialize grammar components
+        this.phraseBuilders = new PhraseBuilders(this.wordProvider, this.rng, this.config);
+        this.sentenceTemplates = new SentenceTemplates(this.phraseBuilders, this.rng, this.config);
+        // Initialize rule engine
+        this.ruleEngine = new RuleEngine(this.config);
+        // Initialize transform registry with V1 defaults
+        this.transformRegistry = createDefaultRegistry();
+        // Set archetype if lexicon has one
+        if (options.lexicon) {
+            const archetypes = Object.keys(options.lexicon.archetypes ?? {});
+            if (archetypes.length > 0) {
+                this.currentArchetype = archetypes[0];
+            }
+        }
+    }
+    /**
+     * Set the random seed for deterministic output
+     */
+    setSeed(seed) {
+        this.currentSeed = seed;
+        this.rng.seed(seed);
+    }
+    /**
+     * Set or replace the lexicon
+     */
+    setLexicon(lexicon) {
+        this.lexiconStore.setLexicon(lexicon);
+        this.currentLexicon = lexicon;
+    }
+    /**
+     * Set the active archetype
+     */
+    setArchetype(name) {
+        this.currentArchetype = name;
+    }
+    /**
+     * Get the transform registry (for registering custom transforms)
+     */
+    getTransformRegistry() {
+        return this.transformRegistry;
+    }
+    /**
+     * Generate a single sentence
+     */
+    sentence(opts) {
+        const ctx = this.createGenerationContext(opts?.hints);
+        // Apply sentence type override if provided
+        const sentenceType = opts?.type;
+        // Generate with retry logic
+        const result = this.generateSentenceWithRetry(ctx, sentenceType);
+        // Apply output transforms
+        const perCallOverride = opts ? {
+            outputTransforms: opts.outputTransforms,
+            mergeMode: opts.mergeMode,
+        } : undefined;
+        const pipelineResult = this.applyOutputTransforms(result.text, perCallOverride);
+        const finalText = pipelineResult.text;
+        if (this.enableTrace) {
+            const trace = this.createSingleSentenceTrace(result, ctx);
+            trace.outputTokens = pipelineResult.outputTokens;
+            trace.transformEvents = pipelineResult.transformEvents;
+            return {
+                text: finalText,
+                trace,
+                meta: {
+                    ...this.getMeta(),
+                    transformsApplied: pipelineResult.transformsApplied.length > 0
+                        ? pipelineResult.transformsApplied : undefined,
+                },
+            };
+        }
+        return finalText;
+    }
+    /**
+     * Generate a paragraph
+     */
+    paragraph(opts) {
+        const ctx = this.createGenerationContext(opts?.hints);
+        const minSentences = opts?.minSentences ?? opts?.sentences ?? this.config.minSentencesPerParagraph;
+        const maxSentences = opts?.maxSentences ?? opts?.sentences ?? this.config.maxSentencesPerParagraph;
+        const numSentences = opts?.sentences ?? this.rng.int(minSentences, maxSentences);
+        const sentences = [];
+        const sentenceTraces = [];
+        for (let i = 0; i < numSentences; i++) {
+            ctx.sentenceIndex = i;
+            clearSentenceState(ctx);
+            const result = this.generateSentenceWithRetry(ctx);
+            sentences.push(result);
+            if (this.enableTrace) {
+                sentenceTraces.push(this.createSentenceTrace(result, ctx));
+            }
+        }
+        const rawText = formatParagraph(sentences.map(s => s.text));
+        // Apply output transforms
+        const perCallOverride = opts ? {
+            outputTransforms: opts.outputTransforms,
+            mergeMode: opts.mergeMode,
+        } : undefined;
+        const pipelineResult = this.applyOutputTransforms(rawText, perCallOverride);
+        const finalText = pipelineResult.text;
+        if (this.enableTrace) {
+            const trace = {
+                paragraphs: [{ sentences: sentenceTraces }],
+                correlationsApplied: this.getAppliedCorrelations(ctx),
+                invariantsChecked: this.checkInvariants(finalText),
+                outputTokens: pipelineResult.outputTokens,
+                transformEvents: pipelineResult.transformEvents,
+            };
+            return {
+                text: finalText,
+                trace,
+                meta: {
+                    ...this.getMeta(),
+                    transformsApplied: pipelineResult.transformsApplied.length > 0
+                        ? pipelineResult.transformsApplied : undefined,
+                },
+            };
+        }
+        return finalText;
+    }
+    /**
+     * Generate a text block (multiple paragraphs)
+     */
+    textBlock(opts) {
+        const minParagraphs = opts?.minParagraphs ?? opts?.paragraphs ?? 1;
+        const maxParagraphs = opts?.maxParagraphs ?? opts?.paragraphs ?? 3;
+        const numParagraphs = opts?.paragraphs ?? this.rng.int(minParagraphs, maxParagraphs);
+        const paragraphs = [];
+        const paragraphTraces = [];
+        for (let i = 0; i < numParagraphs; i++) {
+            const ctx = this.createGenerationContext(opts?.hints);
+            ctx.paragraphIndex = i;
+            const minSentences = this.config.minSentencesPerParagraph;
+            const maxSentences = this.config.maxSentencesPerParagraph;
+            const numSentences = this.rng.int(minSentences, maxSentences);
+            const sentences = [];
+            const sentenceTraces = [];
+            for (let j = 0; j < numSentences; j++) {
+                ctx.sentenceIndex = j;
+                clearSentenceState(ctx);
+                const result = this.generateSentenceWithRetry(ctx);
+                sentences.push(result);
+                if (this.enableTrace) {
+                    sentenceTraces.push(this.createSentenceTrace(result, ctx));
+                }
+            }
+            paragraphs.push(formatParagraph(sentences.map(s => s.text)));
+            if (this.enableTrace) {
+                paragraphTraces.push({ sentences: sentenceTraces });
+            }
+            clearParagraphState(ctx);
+        }
+        const rawText = formatTextBlock(paragraphs);
+        // Apply output transforms
+        const perCallOverride = opts ? {
+            outputTransforms: opts.outputTransforms,
+            mergeMode: opts.mergeMode,
+        } : undefined;
+        const pipelineResult = this.applyOutputTransforms(rawText, perCallOverride);
+        const finalText = pipelineResult.text;
+        if (this.enableTrace) {
+            const ctx = this.createGenerationContext(opts?.hints);
+            const trace = {
+                paragraphs: paragraphTraces,
+                correlationsApplied: this.getAppliedCorrelations(ctx),
+                invariantsChecked: this.checkInvariants(finalText),
+                outputTokens: pipelineResult.outputTokens,
+                transformEvents: pipelineResult.transformEvents,
+            };
+            return {
+                text: finalText,
+                trace,
+                meta: {
+                    ...this.getMeta(),
+                    transformsApplied: pipelineResult.transformsApplied.length > 0
+                        ? pipelineResult.transformsApplied : undefined,
+                },
+            };
+        }
+        return finalText;
+    }
+    /**
+     * Apply output transforms to generated text.
+     * Merges config from: base config → lexicon defaults → archetype → per-call overrides.
+     */
+    applyOutputTransforms(text, perCallOverride) {
+        // Get lexicon-level defaults
+        const lexiconDefaults = this.currentLexicon?.outputTransforms;
+        // Get archetype-level transforms
+        let archetypeTransforms;
+        if (this.currentLexicon?.archetypes?.[this.currentArchetype]) {
+            archetypeTransforms = this.currentLexicon.archetypes[this.currentArchetype].outputTransforms;
+        }
+        // Merge all sources
+        const finalConfig = mergeOutputTransformsConfig(this.config.outputTransforms, lexiconDefaults, archetypeTransforms, perCallOverride ? {
+            outputTransforms: perCallOverride.outputTransforms,
+            mergeMode: perCallOverride.mergeMode,
+        } : undefined);
+        // Execute pipeline
+        return executePipeline(text, finalConfig, this.transformRegistry, this.currentSeed, this.enableTrace);
+    }
+    /**
+     * Create a generation context
+     */
+    createGenerationContext(hints) {
+        const ctx = createContext(this.currentSeed, this.currentArchetype);
+        // Add hints as active tags
+        if (hints) {
+            for (const hint of hints) {
+                ctx.activeTags.add(hint);
+            }
+        }
+        // Add archetype tags
+        const archetype = this.lexiconStore.getArchetype(this.currentArchetype);
+        if (archetype?.tags) {
+            for (const tag of archetype.tags) {
+                ctx.activeTags.add(tag);
+            }
+        }
+        // Merge constraints and invariants
+        ctx.constraints = this.getActiveConstraints();
+        ctx.invariants = this.getActiveInvariants();
+        return ctx;
+    }
+    /**
+     * Generate a sentence with retry logic
+     */
+    generateSentenceWithRetry(ctx, type) {
+        let attempts = 0;
+        let lastResult;
+        let lastError;
+        while (attempts < this.config.maxSentenceAttempts) {
+            attempts++;
+            ctx.retryCount = attempts - 1;
+            try {
+                const result = this.sentenceTemplates.buildSentence(ctx, type);
+                // Validate
+                const validation = this.ruleEngine.validate(ctx.constraints, ctx.invariants, ctx, result.text, result.tokens, 'sentence');
+                if (validation.valid) {
+                    return result;
+                }
+                lastResult = result;
+                // If only soft constraints failed, use this result
+                if (validation.hardConstraintsFailed.length === 0 && validation.invariantsFailed.length === 0) {
+                    return result;
+                }
+                // Apply degradation strategy on subsequent attempts
+                if (attempts > 5) {
+                    // Simplify: reduce complexity for next attempt
+                    this.config.maxPPChain = Math.max(0, this.config.maxPPChain - 1);
+                }
+                if (attempts > 10) {
+                    // Force simple declarative
+                    type = 'simpleDeclarative';
+                }
+            }
+            catch (e) {
+                lastError = e instanceof Error ? e : new Error(String(e));
+            }
+        }
+        // Return best effort or throw
+        if (lastResult) {
+            return lastResult;
+        }
+        if (this.config.strictMode) {
+            throw lastError ?? new Error('Failed to generate valid sentence');
+        }
+        // Fallback: generate simplest possible sentence
+        return this.sentenceTemplates.buildSimpleDeclarative(ctx);
+    }
+    /**
+     * Get active constraints (from lexicon + defaults)
+     */
+    getActiveConstraints() {
+        const defaults = this.ruleEngine.getDefaultConstraints();
+        if (!this.lexiconStore.isLoaded()) {
+            return defaults;
+        }
+        const meta = this.lexiconStore.getMeta();
+        if (!meta)
+            return defaults;
+        // Would need to access lexicon.constraints
+        // For now, return defaults
+        return defaults;
+    }
+    /**
+     * Get active invariants (from lexicon + defaults)
+     */
+    getActiveInvariants() {
+        const defaults = this.ruleEngine.getDefaultInvariants();
+        if (!this.lexiconStore.isLoaded()) {
+            return defaults;
+        }
+        // Would need to access lexicon.invariants
+        // For now, return defaults
+        return defaults;
+    }
+    /**
+     * Get generation metadata
+     */
+    getMeta() {
+        const lexiconMeta = this.lexiconStore.getMeta();
+        return {
+            archetype: this.currentArchetype,
+            seed: this.currentSeed,
+            lexiconVersion: lexiconMeta?.version,
+            lexiconId: lexiconMeta?.id,
+        };
+    }
+    /**
+     * Create a trace for a single sentence result
+     */
+    createSingleSentenceTrace(result, ctx) {
+        return {
+            paragraphs: [
+                {
+                    sentences: [this.createSentenceTrace(result, ctx)],
+                },
+            ],
+            correlationsApplied: this.getAppliedCorrelations(ctx),
+            invariantsChecked: this.checkInvariants(result.text),
+        };
+    }
+    /**
+     * Create a sentence trace
+     */
+    createSentenceTrace(result, ctx) {
+        const tokenTraces = result.tokens.map(token => {
+            // Find if this token came from lexicon or faker
+            const events = ctx.history.events.filter(e => e.type === 'term' && e.item.value === token);
+            const event = events[events.length - 1];
+            return {
+                value: token,
+                source: event?.termSetId ?? 'default',
+                pos: event?.type === 'term' ? event.item.pos : undefined,
+            };
+        });
+        const validation = this.ruleEngine.validate(ctx.constraints, ctx.invariants, ctx, result.text, result.tokens, 'sentence');
+        return {
+            text: result.text,
+            template: result.type,
+            tokens: tokenTraces,
+            constraintsEvaluated: validation.constraintResults.map(r => ({
+                id: r.id,
+                passed: r.passed,
+            })),
+            retryCount: ctx.retryCount,
+        };
+    }
+    /**
+     * Get list of correlations that were applied
+     */
+    getAppliedCorrelations(ctx) {
+        // Would need to track this during generation
+        // For now, return the biases that were set
+        return Array.from(ctx.biases.keys());
+    }
+    /**
+     * Check invariants on final text
+     */
+    checkInvariants(text) {
+        const invariants = this.ruleEngine.getDefaultInvariants();
+        return invariants.map(inv => {
+            const result = this.ruleEngine.evaluateInvariant(inv, text);
+            return { id: result.id, passed: result.passed };
+        });
+    }
+}
+//# sourceMappingURL=text-generator.js.map