@astralarkitekt/tau-tongue 3.6.10

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Astral Arkitekt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,319 @@
+# @astralarkitekt/tau-tongue
+
+**A symbolic narrative algebra for meaning-making and storytelling.**
+
+[![Version](https://img.shields.io/badge/version-3.6.9-blueviolet)]()
+[![TypeScript](https://img.shields.io/badge/TypeScript-ESM-blue)]()
+
+---
+
+## What Is Tau-Tongue?
+
+Tau-Tongue is a deterministic symbolic pipeline that transforms any text into structured narrative data. It converts input text to numbers via Pythagorean numerology, reduces those numbers to digital roots, generates symbolic equations from a 256-operator algebra, decomposes those equations into braids, derives a crucible (thematic core), identifies antagonistic forces, locates inflection points, and produces a full narrative interpretation.
+
+It is not AI. There is no neural network. It is pure algebraic structure — and yet the outputs land with an uncanny resonance because the mathematics of reduction naturally surfaces archetypal patterns in language.
+
+As of v3.6.9, the entire pipeline is **config-injectable**. Supply a `TauTongueConfig` object and every layer — from digital root reduction through narrative interpretation — operates within your custom symbolic system.
+
+**The constraint doesn't change. The vocabulary does.**
+
+Learn more about how to use Tau-Tongue on the Astral Architecture blog!
+
+[Tau-Tongue & Braidcraft: My secret sauce to writing better faster](https://www.astralarchitecture.com/blog/2026/tau-tongue-and-braidcraft/)
+
+Website in the works!
+
+---
+
+## Quick Start
+
+```bash
+npm install @astralarkitekt/tau-tongue
+```
+
+```typescript
+import { TauTongueInterpreter } from '@astralarkitekt/tau-tongue';
+
+const interpreter = new TauTongueInterpreter();
+const result = interpreter.interpret('Once upon a time');
+
+console.log(result.archetype);           // "The Dreamweaver"
+console.log(result.resonance);           // "SOURCE"
+console.log(result.symbolicEquation);    // "∂(1, [∇(3,4),⊗(1,3,9,2,4,4,6), ...])"
+console.log(result.crucible);            // "≳(8) - A mythic potential (≳) acting upon The Mechanist"
+console.log(result.narrativeInterpretation);
+```
+
+The `TauTongueResult` object contains everything: digital root, archetype, resonance, symbolic equation, braid breakdown, crucible, antagonist, inflection points, and narrative interpretation.
+
+---
+
+## Custom Symbolic Systems
+
+The headline feature of v3. Pass a `TauTongueConfig` to the constructor and the entire pipeline adapts:
+
+```typescript
+import { TauTongueInterpreter, SceneFunction } from '@astralarkitekt/tau-tongue';
+
+const jungian = new TauTongueInterpreter({
+  archetypeMap: {
+    1: 'The Hero',
+    2: 'The Shadow',
+    3: 'The Anima',
+    // ... up to 12
+  },
+  archetypeDescriptions: {
+    'The Hero': 'The conscious ego embarking on the journey...',
+    'The Shadow': 'The repressed darkness...',
+    // ...
+  },
+  resonanceMap: {
+    1: 'QUEST',
+    2: 'REPRESSION',
+    3: 'INTUITION',
+    // ...
+  },
+  resonanceDescriptions: {
+    'QUEST': 'The call to adventure...',
+    // ...
+  },
+  archetypeFunctionMap: {
+    1: SceneFunction.ACTION,
+    2: SceneFunction.FLASHBACK,
+    // ...
+  },
+  typalNumbers: [10, 11, 12],
+});
+
+const result = jungian.interpret('What does the shadow want?');
+console.log(result.archetype); // A Jungian archetype, not BraidCraft
+```
+
+### TauTongueConfig
+
+Every field is optional. Omitted fields fall back to the BraidCraft defaults.
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `archetypeMap` | `Record<number, string>` | Digital root → archetype name. Keys define valid reduction endpoints. |
+| `archetypeDescriptions` | `Record<string, string>` | Archetype name → prose description. |
+| `resonanceMap` | `Record<number, string>` | Digital root → resonance label (e.g. `"QUEST"`). |
+| `resonanceDescriptions` | `Record<string, string>` | Resonance label → prose description. |
+| `archetypeFunctionMap` | `Record<number, SceneFunction>` | Digital root → narrative scene function (used by TauSpine). |
+| `symbolMap` | `Record<string, SymbolDefinition>` | Custom operator algebra — symbol → definition. |
+| `typalNumbers` | `number[]` | Numbers that halt digital-root reduction (default: `[11, 22]`). |
+
+### Typal Numbers
+
+A typal number is any multi-digit number you want to preserve as a valid reduction endpoint instead of summing it down to a single digit. In the default BraidCraft system, `11` and `22` are typal. In a Norse system you might use `[24]` for the Elder Futhark count. In a Jungian system, `[10, 11, 12]`.
+
+Single-digit numbers (1–9) don't need to be listed — they're natural endpoints by definition.
+
+---
+
+## API Reference
+
+### Core: `TauTongueInterpreter`
+
+```typescript
+const interpreter = new TauTongueInterpreter(config?: TauTongueConfig);
+```
+
+| Method | Returns | Description |
+|--------|---------|-------------|
+| `interpret(input)` | `TauTongueResult` | Full pipeline: text → digital root → equation → braid → crucible → narrative. |
+| `getCrucible(equation, digitalSum, resonance, archetype)` | `string` | Extract the crucible operator and description from a symbolic equation. |
+| `getMicroCrucible(braidFunction)` | `string` | Get a micro-crucible from a single braid function. |
+| `getAntagonist(equation)` | `TauTongueAntagonist` | Extract the antagonist (longest braid) from the symbolic equation. |
+| `analyzeInterference(result)` | `InflectionPoint[]` | Locate inflection points between braid functions and the interference wave. |
+| `getInterferenceWave(result)` | `string` | Calculate the Braid Interference Wave. |
+| `extractNarrativePalette(braid)` | `NarrativePalette` | Analyze the distribution of scene functions across the braid. |
+| `getFunctionDescription(func)` | `string` | Get a prose description for a symbolic function string. |
+| `render(canvas, result, options?)` | `void` | Render the tau spiral visualization on an HTML canvas. |
+
+### Legacy Interpreters (v1 & v2)
+
+The pre-config-injection interpreters are available under aliased exports for backward compatibility or comparison:
+
+```typescript
+import { TauTongueInterpreterV1, TauTongueInterpreterV2 } from '@astralarkitekt/tau-tongue';
+import type { TauTongueResultV1, TauTongueResultV2 } from '@astralarkitekt/tau-tongue';
+
+const v2 = new TauTongueInterpreterV2();
+const result = v2.interpret('some text'); // Uses hardcoded BraidCraft defaults
+```
+
+These are frozen at their original implementations — no config injection, no `TauTongueConfig`. Use the primary `TauTongueInterpreter` (v3) for new work.
+
+### Narrative Structure: `TauSpine`
+
+`TauSpine` extends `TauTongueInterpreter` and generates recursive narrative trees from interpreted results.
+
+```typescript
+import { createTauSpine, SpineFormat } from '@astralarkitekt/tau-tongue';
+
+const spine = await createTauSpine('Once upon a time', SpineFormat.NOVEL);
+console.log(spine.spine);  // TauSpineNode[]
+console.log(spine.stats);  // { totalNodes, maxDepth, generationTime }
+
+// Or with a custom config:
+const spine = await createTauSpine('Once upon a time', SpineFormat.NOVEL, jungianConfig);
+```
+
+**SpineFormat** determines the narrative scope:
+
+| Format | Value | Description |
+|--------|-------|-------------|
+| `SHORT` | 6 | Short story |
+| `NOVELETTE` | 7 | Novelette |
+| `NOVELLA` | 8 | Novella |
+| `NOVEL` | 9 | Novel |
+| `EPIC` | 11 | Epic |
+| `SAGA` | 22 | Saga |
+
+Spine results can be flattened to a simple scene list via `spine.flatten()`, and scene paths formatted with `getPath(scene)`.
+
+### Pythagorean Utilities
+
+Low-level functions for numerological reduction. These accept an optional `PythagoreanConfig` (derived automatically when using `TauTongueInterpreter`).
+
+| Function | Description |
+|----------|-------------|
+| `convertToNumbers(text)` | Convert text to a string of Pythagorean digit values. |
+| `calculateDigitalRoot(numStr, config?)` | Reduce a number string to its digital root, respecting typal numbers. |
+| `cipherCycle(numeroCipher, resonance, config?)` | Generate a cipher cycle string (async). |
+| `extractBraidDigits(equation)` | Extract braid digits from a symbolic equation string. |
+| `integerStringFromBase36(bs)` | Convert a base-36 string to its integer representation. |
+
+### Symbol Algebra
+
+```typescript
+import { DEFAULT_SYMBOL_MAP } from '@astralarkitekt/tau-tongue';
+import type { SymbolDefinition } from '@astralarkitekt/tau-tongue';
+```
+
+Each `SymbolDefinition` contains:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `name` | `string` | Display name (e.g. "Partial Derivative") |
+| `mathMeaning` | `string` | Formal mathematical meaning |
+| `metaphoricalMeaning` | `string` | Narrative meaning used in interpretation |
+
+### Phoneme Generation
+
+```typescript
+import { generatePhonemeticNames } from '@astralarkitekt/tau-tongue';
+
+const names = generatePhonemeticNames('12345', 0, 10);
+// Returns 10 phonemic word variations derived from the numerocipher
+```
+
+### Default Constants
+
+All BraidCraft defaults are available as named exports:
+
+- `DEFAULT_ARCHETYPE_MAP`
+- `DEFAULT_ARCHETYPE_DESCRIPTIONS`
+- `DEFAULT_RESONANCE_MAP`
+- `DEFAULT_RESONANCE_DESCRIPTIONS`
+- `DEFAULT_ARCHETYPE_FUNCTION_MAP`
+- `DEFAULT_SYMBOL_MAP`
+- `DEFAULT_TYPAL_NUMBERS`
+
+### Types
+
+All TypeScript types are exported:
+
+```typescript
+import type {
+  TauTongueConfig,
+  TauTongueResult,
+  TauTongueAntagonist,
+  BraidInterpretation,
+  InflectionPoint,
+  NarrativePalette,
+  RenderOptions,
+  PythagoreanConfig,
+  SymbolDefinition,
+  TauSpineNode,
+  TauSpineResult,
+  FlattenedTauSpineResult,
+  FlattenedScene,
+  ArchetypalMatrix,
+  ArchetypalEntry,
+  FormatData,
+  UnitSpec,
+} from '@astralarkitekt/tau-tongue';
+```
+
+---
+
+## Demo Gallery
+
+Live demos at [tools.astralarchitecture.com/tau-tongue](https://tools.astralarchitecture.com/tau-tongue/):
+
+| Demo | Description |
+|------|-------------|
+| [Interpreter](https://tools.astralarchitecture.com/tau-tongue/demos/interpreter.html) | Full result workbench — digital root, archetype, equation, braid, crucible, narrative. |
+| [Spine Generator](https://tools.astralarchitecture.com/tau-tongue/demos/spine-generator.html) | Recursive `TauSpine` tree visualization from input text. |
+| [TauSigils](https://tools.astralarchitecture.com/tau-tongue/demos/TauSigils.html) | Ethereal continuous-line sigil drawings from braid structure. |
+| [TauGlyphs](https://tools.astralarchitecture.com/tau-tongue/demos/TauGlyphs.html) | Colored node graphs showing structural braid relationships. |
+| [TauAlchemy](https://tools.astralarchitecture.com/tau-tongue/demos/TauAlchemy.html) | Animated alchemical seal geometry driven by braid data. |
+| [TauAstrolabe](https://tools.astralarchitecture.com/tau-tongue/demos/TauAstrolabe.html) | Alchemical system (v3 config) — celestial orbit visualization. |
+| [TauAether](https://tools.astralarchitecture.com/tau-tongue/demos/TauAether.html) | Norse Runic system (v3 config) — organic aether energy fields. |
+| [Jung-Tongue](https://tools.astralarchitecture.com/tau-tongue/demos/JungTongue.html) | Jungian chatbot — 12 archetypes, session persistence, voice input. |
+
+---
+
+## Project Structure
+
+```
+src/
+  index.ts                          # Public API re-exports
+  pythagoreanUtils.ts               # Numerological reduction utilities
+  phonemeCipher.ts                  # Phonemic name generation
+  tau-tongue/
+    TauTongueInterpreter_v3.ts      # Core interpreter — config-injectable (v3)
+    TauTongueInterpreter_v2.ts      # Legacy interpreter (v2, pre-config)
+    TauTongueInterpreter_v1.ts      # Legacy interpreter (v1)
+    TauSpine.ts                     # Recursive narrative structure generator
+    TauTongueSymbolMap.ts           # 256-operator symbol algebra
+    TauTongueRenderer.ts            # Canvas spiral renderer
+    TauTongueFictionTypeMap.ts      # Fiction type classification
+    TauTomeCoverRenderer.ts         # Book cover generation
+    symbol-map.json                 # Symbol definitions data
+    archetype-fiction-type-map.json  # Archetype → fiction type mapping
+    story-unit-specs.json           # Narrative unit specifications
+demos/
+  interpreter.html                  # Full result workbench
+  spine-generator.html              # TauSpine tree visualizer
+  TauSigils.html                    # Sigil art renderer
+  TauGlyphs.html                    # Glyph graph renderer
+  TauAlchemy.html                   # Alchemical seal geometry
+  TauAstrolabe.html                 # Alchemical config demo (v3)
+  TauAether.html                    # Norse Runic config demo (v3)
+  JungTongue.html                   # Jungian chatbot demo
+  jung-tongue-config.js             # Jungian symbolic system config
+```
+
+---
+
+## Development
+
+```bash
+git clone https://github.com/astralarkitekt/tau-tongue.git
+cd tau-tongue
+npm install
+npm run build          # Compiles TypeScript to dist/
+```
+
+Demos load from `../dist/index.js` as ES modules — open any HTML file in `demos/` after building.
+
+---
+
+## Author
+
+**Astral Arkitekt** — [astralarkitekt@gmail.com](mailto:astralarkitekt@gmail.com)
+
+Built with deterministic algebra, insomnia, and an unreasonable amount of love. I mean coffee.

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+export { TauTongueInterpreter, DEFAULT_ARCHETYPE_MAP, DEFAULT_ARCHETYPE_DESCRIPTIONS, DEFAULT_RESONANCE_MAP, DEFAULT_RESONANCE_DESCRIPTIONS, DEFAULT_ARCHETYPE_FUNCTION_MAP, SceneFunction, } from './tau-tongue/TauTongueInterpreter_v3.js';
+export type { TauTongueResult, TauTongueAntagonist, BraidInterpretation, InflectionPoint, RenderOptions, NarrativePalette, TauTongueConfig, } from './tau-tongue/TauTongueInterpreter_v3.js';
+export { TauTongueInterpreter as TauTongueInterpreterV1, } from './tau-tongue/TauTongueInterpreter_v1.js';
+export type { TauTongueResult as TauTongueResultV1, } from './tau-tongue/TauTongueInterpreter_v1.js';
+export { TauTongueInterpreter as TauTongueInterpreterV2, } from './tau-tongue/TauTongueInterpreter_v2.js';
+export type { TauTongueResult as TauTongueResultV2, TauTongueAntagonist as TauTongueAntagonistV2, BraidInterpretation as BraidInterpretationV2, InflectionPoint as InflectionPointV2, NarrativePalette as NarrativePaletteV2, } from './tau-tongue/TauTongueInterpreter_v2.js';
+export { TauSpine, createTauSpine, SpineFormat, getPath } from './tau-tongue/TauSpine.js';
+export type { TauSpineNode, TauSpineResult, FlattenedTauSpineResult, FlattenedScene, FormatData, UnitSpec, ArchetypalEntry, ArchetypalMatrix } from './tau-tongue/TauSpine.js';
+export { numerologyMap, convertToNumbers, calculateDigitalRoot, integerStringFromBase36, cipherCycle, extractBraidDigits, DEFAULT_TYPAL_NUMBERS } from './pythagoreanUtils.js';
+export type { PythagoreanConfig } from './pythagoreanUtils.js';
+export { guessPythagoreanWord as generatePhonemeticNames } from './phonemeCipher.js';
+export { getSymbol, getSymbols, DEFAULT_SYMBOL_MAP } from './tau-tongue/TauTongueSymbolMap.js';
+export type { SymbolDefinition } from './tau-tongue/TauTongueSymbolMap.js';
+export { renderTauSpiral } from './tau-tongue/TauTongueRenderer.js';
+export type { TauInput } from './tau-tongue/TauTongueRenderer.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,oBAAoB,EACpB,qBAAqB,EACrB,8BAA8B,EAC9B,qBAAqB,EACrB,8BAA8B,EAC9B,8BAA8B,EAC9B,aAAa,GACd,MAAM,yCAAyC,CAAC;AACjD,YAAY,EACV,eAAe,EACf,mBAAmB,EACnB,mBAAmB,EACnB,eAAe,EACf,aAAa,EACb,gBAAgB,EAChB,eAAe,GAChB,MAAM,yCAAyC,CAAC;AAGjD,OAAO,EACL,oBAAoB,IAAI,sBAAsB,GAC/C,MAAM,yCAAyC,CAAC;AACjD,YAAY,EACV,eAAe,IAAI,iBAAiB,GACrC,MAAM,yCAAyC,CAAC;AAEjD,OAAO,EACL,oBAAoB,IAAI,sBAAsB,GAC/C,MAAM,yCAAyC,CAAC;AACjD,YAAY,EACV,eAAe,IAAI,iBAAiB,EACpC,mBAAmB,IAAI,qBAAqB,EAC5C,mBAAmB,IAAI,qBAAqB,EAC5C,eAAe,IAAI,iBAAiB,EACpC,gBAAgB,IAAI,kBAAkB,GACvC,MAAM,yCAAyC,CAAC;AAGjD,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAC1F,YAAY,EACV,YAAY,EACZ,cAAc,EACd,uBAAuB,EACvB,cAAc,EACd,UAAU,EACV,QAAQ,EACR,eAAe,EACf,gBAAgB,EACjB,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,oBAAoB,EACpB,uBAAuB,EACvB,WAAW,EACX,kBAAkB,EAClB,qBAAqB,EACtB,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAG/D,OAAO,EAAE,oBAAoB,IAAI,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAGrF,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAC/F,YAAY,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACpE,YAAY,EAAE,QAAQ,EAAE,MAAM,mCAAmC,CAAC"}

package/dist/index.js

@@ -0,0 +1,14 @@
+// Main exports for the Tau-Tongue library (v3 — config-injectable)
+export { TauTongueInterpreter, DEFAULT_ARCHETYPE_MAP, DEFAULT_ARCHETYPE_DESCRIPTIONS, DEFAULT_RESONANCE_MAP, DEFAULT_RESONANCE_DESCRIPTIONS, DEFAULT_ARCHETYPE_FUNCTION_MAP, SceneFunction, } from './tau-tongue/TauTongueInterpreter_v3.js';
+// Legacy interpreter exports (v1 and v2 — hardcoded BraidCraft defaults)
+export { TauTongueInterpreter as TauTongueInterpreterV1, } from './tau-tongue/TauTongueInterpreter_v1.js';
+export { TauTongueInterpreter as TauTongueInterpreterV2, } from './tau-tongue/TauTongueInterpreter_v2.js';
+// TauSpine exports
+export { TauSpine, createTauSpine, SpineFormat, getPath } from './tau-tongue/TauSpine.js';
+// Pythagorean utilities
+export { numerologyMap, convertToNumbers, calculateDigitalRoot, integerStringFromBase36, cipherCycle, extractBraidDigits, DEFAULT_TYPAL_NUMBERS } from './pythagoreanUtils.js';
+// Phoneme cipher utilities
+export { guessPythagoreanWord as generatePhonemeticNames } from './phonemeCipher.js';
+// Tau-Tongue core components
+export { getSymbol, getSymbols, DEFAULT_SYMBOL_MAP } from './tau-tongue/TauTongueSymbolMap.js';
+export { renderTauSpiral } from './tau-tongue/TauTongueRenderer.js';

package/dist/phonemeCipher.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Generate multiple phonemic variations from a numerocipher
+ * @param input - The numerocipher string
+ * @param augment - Base augment value for variation
+ * @param results - Number of results to generate (default: 10)
+ * @returns Array of phonemic strings
+ */
+export declare const guessPythagoreanWord: (input: string, augment?: number, results?: number) => string[];
+//# sourceMappingURL=phonemeCipher.d.ts.map

package/dist/phonemeCipher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"phonemeCipher.d.ts","sourceRoot":"","sources":["../src/phonemeCipher.ts"],"names":[],"mappings":"AAuGA;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,GAC/B,OAAO,MAAM,EACb,UAAS,MAAU,EACnB,UAAS,MAAW,KACnB,MAAM,EAUR,CAAC"}

package/dist/phonemeCipher.js

@@ -0,0 +1,97 @@
+// phonemicGenerator.ts
+import { calculateDigitalRoot } from './pythagoreanUtils.js';
+// Reverse mapping: number to possible letters
+const reverseNumerologyMap = {
+    1: ['A', 'J', 'S'],
+    2: ['B', 'K', 'T'],
+    3: ['C', 'L', 'U'],
+    4: ['D', 'M', 'V'],
+    5: ['E', 'N', 'W'],
+    6: ['F', 'O', 'X'],
+    7: ['G', 'P', 'Y'],
+    8: ['H', 'Q', 'Z'],
+    9: ['I', 'R']
+};
+const isVowel = (char) => 'AEIOUYW'.includes(char.toUpperCase());
+const getCharacterType = (char) => {
+    if (isVowel(char))
+        return 'vowel';
+    if (/[BCDFGHJKLMNPQRSTVXZ]/i.test(char))
+        return 'consonant';
+    return 'other';
+};
+const selectCharacterBySyllable = (options, seed, expectedType, context) => {
+    // Filter by expected type
+    let filteredOptions = options;
+    if (expectedType !== 'any') {
+        filteredOptions = options.filter(char => getCharacterType(char) === expectedType);
+    }
+    // If no options match, fall back to all options
+    if (filteredOptions.length === 0) {
+        filteredOptions = options;
+    }
+    // Avoid repetition
+    if (context.prev) {
+        const nonRepeating = filteredOptions.filter(char => char !== context.prev);
+        if (nonRepeating.length > 0) {
+            filteredOptions = nonRepeating;
+        }
+    }
+    // Deterministic selection
+    const index = ((seed * 7919) % filteredOptions.length + filteredOptions.length) % filteredOptions.length;
+    return filteredOptions[index];
+};
+const generateSinglePhonemeticName = (numeroCipher, augment = 0) => {
+    if (!numeroCipher || numeroCipher.length === 0)
+        return '';
+    const digitalRoot = calculateDigitalRoot(numeroCipher) || 1;
+    let result = '';
+    for (let i = 0; i < numeroCipher.length; i++) {
+        const digit = parseInt(numeroCipher[i]);
+        if (isNaN(digit) || digit === 0) {
+            result += numeroCipher[i];
+            continue;
+        }
+        const options = reverseNumerologyMap[digit] || [];
+        if (options.length === 0) {
+            result += numeroCipher[i];
+            continue;
+        }
+        // Determine what type of character we want based on position in syllable
+        let expectedType = 'any';
+        const positionInSyllable = i % 3; // Simple 3-beat syllable pattern
+        if (positionInSyllable === 0) {
+            expectedType = result.length === 0 ? 'consonant' : 'any'; // Prefer consonants at start
+        }
+        else if (positionInSyllable === 1) {
+            expectedType = 'vowel'; // Prefer vowels in middle
+        }
+        else {
+            expectedType = 'consonant'; // Prefer consonants at end
+        }
+        const seed = (digitalRoot * 13) + (augment * 97) + (i * 17) + (digit * 23);
+        const context = {
+            prev: result[result.length - 1],
+            position: i
+        };
+        const selectedChar = selectCharacterBySyllable(options, seed, expectedType, context);
+        result += selectedChar;
+    }
+    return result;
+};
+/**
+ * Generate multiple phonemic variations from a numerocipher
+ * @param input - The numerocipher string
+ * @param augment - Base augment value for variation
+ * @param results - Number of results to generate (default: 10)
+ * @returns Array of phonemic strings
+ */
+export const guessPythagoreanWord = (input, augment = 0, results = 10) => {
+    const variations = [];
+    for (let i = 0; i < results; i++) {
+        const currentAugment = augment + (i * 13); // Larger step between variations
+        const variation = generateSinglePhonemeticName(input, currentAugment);
+        variations.push(variation);
+    }
+    return variations;
+};

package/dist/pythagoreanUtils.d.ts

@@ -0,0 +1,28 @@
+export declare const numerologyMap: Record<string, number>;
+export declare const convertToNumbers: (text: string) => string;
+/**
+ * Low-level Pythagorean numerology configuration.
+ * Derived automatically from {@link TauTongueConfig} — consumers
+ * should not need to construct this directly.
+ */
+export interface PythagoreanConfig {
+    /** Map of digital-root keys to archetype names. Keys that appear here are treated as valid reduction endpoints. */
+    archetypes: Record<number, string>;
+    /** Numbers that halt digital-root reduction (default: `[11, 22]`). */
+    typalNumbers?: number[];
+}
+/** Default typal (master) numbers in classical Pythagorean numerology. */
+export declare const DEFAULT_TYPAL_NUMBERS: number[];
+export declare const calculateDigitalRoot: (numStr: string, config?: PythagoreanConfig) => number | null;
+export declare function integerStringFromBase36(bs: string): string;
+/**
+ * Cipher cycling - evolve the numerical signature
+ */
+export declare const cipherCycle: (numeroCipher: string, resonance: number, config?: PythagoreanConfig) => Promise<string>;
+/**
+ * Extract braid digits from a tau-tongue equation string.
+ * @param equation - tau-tongue equation string
+ * @returns Braid digits as a string
+ */
+export declare const extractBraidDigits: (equation: string) => string;
+//# sourceMappingURL=pythagoreanUtils.d.ts.map

package/dist/pythagoreanUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pythagoreanUtils.d.ts","sourceRoot":"","sources":["../src/pythagoreanUtils.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CA2BhD,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,MAAM,MAAM,KAAG,MAW/C,CAAC;AAEF;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC,mHAAmH;IACnH,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,sEAAsE;IACtE,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB;AAED,0EAA0E;AAC1E,eAAO,MAAM,qBAAqB,EAAE,MAAM,EAAa,CAAC;AAExD,eAAO,MAAM,oBAAoB,GAAI,QAAQ,MAAM,EAAE,SAAS,iBAAiB,KAAG,MAAM,GAAG,IA6B1F,CAAC;AAEF,wBAAgB,uBAAuB,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAgB1D;AAoBD;;GAEG;AACH,eAAO,MAAM,WAAW,GAAU,cAAc,MAAM,EAAE,WAAW,MAAM,EAAE,SAAS,iBAAiB,KAAG,OAAO,CAAC,MAAM,CAmCrH,CAAA;AAID;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,GAAI,UAAU,MAAM,KAAG,MAIrD,CAAC"}

package/dist/pythagoreanUtils.js

@@ -0,0 +1,141 @@
+// Mapping of letters to numbers
+export const numerologyMap = {
+    A: 1,
+    J: 1,
+    S: 1,
+    B: 2,
+    K: 2,
+    T: 2,
+    C: 3,
+    L: 3,
+    U: 3,
+    D: 4,
+    M: 4,
+    V: 4,
+    E: 5,
+    N: 5,
+    W: 5,
+    F: 6,
+    O: 6,
+    X: 6,
+    G: 7,
+    P: 7,
+    Y: 7,
+    H: 8,
+    Q: 8,
+    Z: 8,
+    I: 9,
+    R: 9,
+};
+export const convertToNumbers = (text) => {
+    // if the provided string contains NO letters and IS all numbers, return it as is
+    if (/^[0-9\s]+$/.test(text)) {
+        return text;
+    }
+    return text
+        .toUpperCase()
+        .split("")
+        .map((char) => numerologyMap[char] || char)
+        .join("");
+};
+/** Default typal (master) numbers in classical Pythagorean numerology. */
+export const DEFAULT_TYPAL_NUMBERS = [11, 22];
+export const calculateDigitalRoot = (numStr, config) => {
+    // Filter out non-numeric characters and convert to array of numbers
+    const numbers = numStr
+        .split('')
+        .filter(char => !isNaN(parseInt(char)))
+        .map(Number);
+    if (numbers.length === 0)
+        return null;
+    const isValidRoot = (n) => {
+        if (config) {
+            return config.archetypes[n] !== undefined ||
+                (config.typalNumbers ?? DEFAULT_TYPAL_NUMBERS).includes(n);
+        }
+        return n < 10 || n === 11 || n === 22; // backward compat default
+    };
+    // Initial sum
+    let sum = numbers.reduce((acc, curr) => acc + curr, 0);
+    // Keep reducing until we get a valid root
+    while (!isValidRoot(sum)) {
+        sum = String(sum)
+            .split('')
+            .map(Number)
+            .reduce((acc, curr) => acc + curr, 0);
+    }
+    return sum;
+};
+export function integerStringFromBase36(bs) {
+    let result = 0n;
+    const base = 36n;
+    for (const ch of bs.toUpperCase()) {
+        const code = ch.charCodeAt(0);
+        // ‘0’–‘9’ → 0–9, ‘A’–‘Z’ → 10–35
+        const digit = code >= 48 && code <= 57 ? BigInt(code - 48)
+            : code >= 65 && code <= 90 ? BigInt(code - 65 + 10)
+                : (() => { throw new Error(`Invalid base36 digit “${ch}”`); })();
+        result = result * base + digit;
+    }
+    return result.toString();
+}
+/**
+ * SHA-256 hash that works in both Node.js and browser environments
+ */
+async function sha256Hash(input) {
+    // Check if we're in a browser environment
+    if (typeof window !== 'undefined' && window.crypto && window.crypto.subtle) {
+        const encoder = new TextEncoder();
+        const data = encoder.encode(input);
+        const hashBuffer = await window.crypto.subtle.digest('SHA-256', data);
+        const hashArray = Array.from(new Uint8Array(hashBuffer));
+        return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
+    }
+    // Node.js environment - dynamically import hash-wasm
+    const { sha256 } = await import('hash-wasm');
+    return sha256(input);
+}
+/**
+ * Cipher cycling - evolve the numerical signature
+ */
+export const cipherCycle = async (numeroCipher, resonance, config) => {
+    const digits = numeroCipher.split('').map(Number);
+    // create a sha256 hash of the input numeroCipher 
+    const hash = await sha256Hash(numeroCipher);
+    const BigIntHash = BigInt('0x' + hash);
+    const evolved = [];
+    for (let i = 0; i < digits.length; i++) {
+        const digit = digits[i];
+        let newDigit = calculateDigitalRoot((BigIntHash / BigInt((digit + resonance + i) * resonance)).toString(), config);
+        if (newDigit === null) {
+            throw new Error(`Invalid digit encountered: ${digit}`);
+        }
+        if (!config) {
+            if (newDigit === 11)
+                newDigit = 2; // Treat master number 11 as 2
+            if (newDigit === 22)
+                newDigit = 4; // Treat master number 22 as 4
+        }
+        else {
+            const typal = config.typalNumbers ?? DEFAULT_TYPAL_NUMBERS;
+            if (typal.includes(newDigit) && config.archetypes[newDigit] === undefined) {
+                // collapse typal numbers to single-digit equivalents
+                while (newDigit > 9) {
+                    newDigit = String(newDigit).split('').map(Number).reduce((a, b) => a + b, 0);
+                }
+            }
+        }
+        evolved.push(newDigit);
+    }
+    return evolved.join('');
+};
+/**
+ * Extract braid digits from a tau-tongue equation string.
+ * @param equation - tau-tongue equation string
+ * @returns Braid digits as a string
+ */
+export const extractBraidDigits = (equation) => {
+    // extract braid from equation (every digit between the [ and ] characters)
+    const braidMatch = equation.match(/\[(.*?)\]/);
+    return braidMatch ? braidMatch[1].replace(/\D/g, '') : '';
+};