{"_id":"@astralarkitekt/tau-tongue","_rev":"5-89cee6d94211067169d2a73c6bd9ae06","name":"@astralarkitekt/tau-tongue","dist-tags":{"latest":"3.9.1"},"versions":{"3.6.10":{"name":"@astralarkitekt/tau-tongue","version":"3.6.10","keywords":["symbolic-algebra","narrative-generation","procedural-generation","numerology","pythagorean","storytelling","text-analysis","digital-root","braids","archetypes","config-injectable","tau-tongue","braidcraft"],"author":{"name":"Astral Arkitekt","email":"astralarkitekt@gmail.com"},"license":"MIT","_id":"@astralarkitekt/tau-tongue@3.6.10","maintainers":[{"name":"astralarkitekt","email":"Astralarkitekt@gmail.com"}],"homepage":"https://github.com/astralarkitekt/tau-tongue#readme","bugs":{"url":"https://github.com/astralarkitekt/tau-tongue/issues"},"dist":{"shasum":"9f18a7dfa4fd74de710f53344ab1c959b6dd5866","tarball":"https://registry.npmjs.org/@astralarkitekt/tau-tongue/-/tau-tongue-3.6.10.tgz","fileCount":38,"integrity":"sha512-iwAuNnkd6fbMfPet9JVdeUNUOLfRdTWvle07whb1wpOgPuTLOk2vQ7EK4S+wR2WEQL8u223i+UVY19hQ99BkwQ==","signatures":[{"sig":"MEYCIQDs3uCX8zmXkGNu/kOZkHodPE34yKvhkYF6EGvyLfyd3AIhAPLBU7cUMHI0DjXKWTvEnRkSMllCToQGO6LQNtkBcLMm","keyid":"SHA256:DhQ8wR5APBvFHLF/+Tc+AYvPOdTpcIDqOhxsBHRwC7U"}],"unpackedSize":215093},"main":"dist/index.js","type":"module","types":"dist/index.d.ts","gitHead":"abd28aa37a33b653e87607f4ec7f2bb54677fdb4","scripts":{"build":"tsc","prepublishOnly":"npm run build"},"_npmUser":{"name":"astralarkitekt","email":"Astralarkitekt@gmail.com"},"repository":{"url":"git+https://github.com/astralarkitekt/tau-tongue.git","type":"git"},"_npmVersion":"10.9.2","description":"Tau-Tongue is a symbolic narrative algebra for meaning-making and storytelling, designed to help users construct and explore narratives through a structured framework.","directories":{},"_nodeVersion":"22.15.0","dependencies":{"canvas":"^3.2.0","hash-wasm":"^4.12.0"},"publishConfig":{"access":"public","registry":"https://registry.npmjs.org/"},"_hasShrinkwrap":false,"devDependencies":{"typescript":"^5.2.2","@types/node":"^24.6.2"},"_npmOperationalInternal":{"tmp":"tmp/tau-tongue_3.6.10_1772420086316_0.6830740520189265","host":"s3://npm-registry-packages-npm-production"}},"3.7.0":{"name":"@astralarkitekt/tau-tongue","version":"3.7.0","keywords":["symbolic-algebra","narrative-generation","procedural-generation","numerology","pythagorean","storytelling","text-analysis","digital-root","braids","archetypes","config-injectable","tau-tongue","braidcraft"],"author":{"name":"Astral Arkitekt","email":"astralarkitekt@gmail.com"},"license":"MIT","_id":"@astralarkitekt/tau-tongue@3.7.0","maintainers":[{"name":"astralarkitekt","email":"Astralarkitekt@gmail.com"}],"homepage":"https://github.com/astralarkitekt/tau-tongue#readme","bugs":{"url":"https://github.com/astralarkitekt/tau-tongue/issues"},"dist":{"shasum":"6fedb9621f5a671640de2f067ca5e7b5e70fe47a","tarball":"https://registry.npmjs.org/@astralarkitekt/tau-tongue/-/tau-tongue-3.7.0.tgz","fileCount":38,"integrity":"sha512-GkQAuf/9myUYwXNl6rmM0h5trDFua6UsUDVzMj8/9vXYQXXBjs13ESkXec5UFupNwl3f2Izfh2GWCvEXE+5eAw==","signatures":[{"sig":"MEUCIBesrTsgNPEM/30NsDpUm6uG7wV17epY1K1DkFnVBIDLAiEA4sJzQ0Y+IWoTDg9XdWY4BPkPVcrKjNqALeZOsktV1pA=","keyid":"SHA256:DhQ8wR5APBvFHLF/+Tc+AYvPOdTpcIDqOhxsBHRwC7U"}],"unpackedSize":215265},"main":"dist/index.js","type":"module","types":"dist/index.d.ts","gitHead":"c9ccf93cf86de150d85a6c8007f8c948a125a6c5","scripts":{"build":"tsc","prepublishOnly":"npm run build"},"_npmUser":{"name":"astralarkitekt","email":"Astralarkitekt@gmail.com"},"repository":{"url":"git+https://github.com/astralarkitekt/tau-tongue.git","type":"git"},"_npmVersion":"10.9.2","description":"Tau-Tongue is a symbolic narrative algebra for meaning-making and storytelling, designed to help users construct and explore narratives through a structured framework.","directories":{},"_nodeVersion":"22.15.0","dependencies":{"canvas":"^3.2.0","hash-wasm":"^4.12.0"},"publishConfig":{"access":"public","registry":"https://registry.npmjs.org/"},"_hasShrinkwrap":false,"devDependencies":{"typescript":"^5.2.2","@types/node":"^24.6.2"},"_npmOperationalInternal":{"tmp":"tmp/tau-tongue_3.7.0_1772554461827_0.11708643559268017","host":"s3://npm-registry-packages-npm-production"}},"3.8.0":{"name":"@astralarkitekt/tau-tongue","version":"3.8.0","keywords":["symbolic-algebra","narrative-generation","procedural-generation","numerology","pythagorean","storytelling","text-analysis","digital-root","braids","archetypes","config-injectable","tau-tongue","braidcraft"],"author":{"name":"Astral Arkitekt","email":"astralarkitekt@gmail.com"},"license":"MIT","_id":"@astralarkitekt/tau-tongue@3.8.0","maintainers":[{"name":"astralarkitekt","email":"Astralarkitekt@gmail.com"}],"homepage":"https://github.com/astralarkitekt/tau-tongue#readme","bugs":{"url":"https://github.com/astralarkitekt/tau-tongue/issues"},"dist":{"shasum":"8868793f72d2fbe9eff4baa759be335fbf239381","tarball":"https://registry.npmjs.org/@astralarkitekt/tau-tongue/-/tau-tongue-3.8.0.tgz","fileCount":38,"integrity":"sha512-1vEkfIM8CdcwZJPnm7eD4j4r7ssFcxQm8j3Gra+fsFY75RtD2DKVdkOdczdKJfYpTSM2hNQcqkQTbsknw9IsvQ==","signatures":[{"sig":"MEQCIC1q3ytj8IbW6AHPYgFKXK7ewUiwYSuaPXzPWSoHZT90AiBQQoeClh+Sqg6iNgUgUjwUqbyZl+h6jPI4gBm40xZhhQ==","keyid":"SHA256:DhQ8wR5APBvFHLF/+Tc+AYvPOdTpcIDqOhxsBHRwC7U"}],"unpackedSize":221844},"main":"dist/index.js","type":"module","types":"dist/index.d.ts","gitHead":"f680e8cea93dc6d2b5ac16e33057e2c35c6c5870","scripts":{"build":"tsc","prepublishOnly":"npm run build"},"_npmUser":{"name":"astralarkitekt","email":"Astralarkitekt@gmail.com"},"repository":{"url":"git+https://github.com/astralarkitekt/tau-tongue.git","type":"git"},"_npmVersion":"10.9.2","description":"Tau-Tongue is a symbolic narrative algebra for meaning-making and storytelling, designed to help users construct and explore narratives through a structured framework.","directories":{},"_nodeVersion":"22.15.0","dependencies":{"canvas":"^3.2.0","hash-wasm":"^4.12.0"},"publishConfig":{"access":"public","registry":"https://registry.npmjs.org/"},"_hasShrinkwrap":false,"devDependencies":{"typescript":"^5.2.2","@types/node":"^24.6.2"},"_npmOperationalInternal":{"tmp":"tmp/tau-tongue_3.8.0_1773447375192_0.25209163934437084","host":"s3://npm-registry-packages-npm-production"}},"3.9.0":{"name":"@astralarkitekt/tau-tongue","version":"3.9.0","keywords":["symbolic-algebra","narrative-generation","procedural-generation","numerology","pythagorean","storytelling","text-analysis","digital-root","braids","archetypes","config-injectable","tau-tongue","braidcraft"],"author":{"name":"Astral Arkitekt","email":"astralarkitekt@gmail.com"},"license":"MIT","_id":"@astralarkitekt/tau-tongue@3.9.0","maintainers":[{"name":"astralarkitekt","email":"Astralarkitekt@gmail.com"}],"homepage":"https://github.com/astralarkitekt/tau-tongue#readme","bugs":{"url":"https://github.com/astralarkitekt/tau-tongue/issues"},"dist":{"shasum":"115525da80741a541e224b309b29fe022f3412f8","tarball":"https://registry.npmjs.org/@astralarkitekt/tau-tongue/-/tau-tongue-3.9.0.tgz","fileCount":38,"integrity":"sha512-caMAU1oEwWKmfV5iGY8+kbT0F05zwruHrHFnUIMHujx8haYMZ3Tr5fbrSjVeFnVXyoep9HG+UBGodWQrILhNpw==","signatures":[{"sig":"MEYCIQCxKXXdQTQtHRemekGBoYFRdsMSGu+l5l8rKR7FIovMTAIhAI3spg0JXLoqwQkC4EaIsQJfo6r7mdNXl0KhE00uJzlf","keyid":"SHA256:DhQ8wR5APBvFHLF/+Tc+AYvPOdTpcIDqOhxsBHRwC7U"}],"unpackedSize":224578},"main":"dist/index.js","type":"module","types":"dist/index.d.ts","gitHead":"242ded9f9155a7930792efe92b5ff548e69bd2f7","scripts":{"build":"tsc","prepublishOnly":"npm run build"},"_npmUser":{"name":"astralarkitekt","email":"Astralarkitekt@gmail.com"},"repository":{"url":"git+https://github.com/astralarkitekt/tau-tongue.git","type":"git"},"_npmVersion":"10.9.2","description":"Tau-Tongue is a symbolic narrative algebra for meaning-making and storytelling, designed to help users construct and explore narratives through a structured framework.","directories":{},"_nodeVersion":"22.15.0","dependencies":{"canvas":"^3.2.0","hash-wasm":"^4.12.0"},"publishConfig":{"access":"public","registry":"https://registry.npmjs.org/"},"_hasShrinkwrap":false,"devDependencies":{"typescript":"^5.2.2","@types/node":"^24.6.2"},"_npmOperationalInternal":{"tmp":"tmp/tau-tongue_3.9.0_1774125506109_0.2317676525869894","host":"s3://npm-registry-packages-npm-production"}},"3.9.1":{"name":"@astralarkitekt/tau-tongue","version":"3.9.1","author":{"name":"Astral Arkitekt","email":"astralarkitekt@gmail.com"},"description":"Tau-Tongue is a symbolic narrative algebra for meaning-making and storytelling, designed to help users construct and explore narratives through a structured framework.","type":"module","main":"dist/index.js","types":"dist/index.d.ts","scripts":{"build":"tsc","prepublishOnly":"npm run build"},"repository":{"type":"git","url":"git+https://github.com/astralarkitekt/tau-tongue.git"},"license":"MIT","publishConfig":{"registry":"https://registry.npmjs.org/","access":"public"},"devDependencies":{"@types/node":"^24.6.2","typescript":"^5.2.2"},"keywords":["symbolic-algebra","narrative-generation","procedural-generation","numerology","pythagorean","storytelling","text-analysis","digital-root","braids","archetypes","config-injectable","tau-tongue","braidcraft"],"dependencies":{"canvas":"^3.2.0","hash-wasm":"^4.12.0"},"_id":"@astralarkitekt/tau-tongue@3.9.1","gitHead":"1634b40b0a59b875eed9a7fdff25aea755e297b4","bugs":{"url":"https://github.com/astralarkitekt/tau-tongue/issues"},"homepage":"https://github.com/astralarkitekt/tau-tongue#readme","_nodeVersion":"22.15.0","_npmVersion":"10.9.2","dist":{"integrity":"sha512-6VKFR/hMAi6dbdiy/NWGzE+58SwscT8ZKB6jAEGOnHRm9r03ec2quthnyt7os7klE9s7P/+1MwKLtqnaI+6l+w==","shasum":"8c8ec2b997b942af49aa1e606c4220983e37879b","tarball":"https://registry.npmjs.org/@astralarkitekt/tau-tongue/-/tau-tongue-3.9.1.tgz","fileCount":38,"unpackedSize":224572,"signatures":[{"keyid":"SHA256:DhQ8wR5APBvFHLF/+Tc+AYvPOdTpcIDqOhxsBHRwC7U","sig":"MEUCIQCLgeDznrZpThvdAaPhCQcFnHwJeBHjm0lNv0VVeuo14QIgF0mRuflYE8PnutNz2x8PqavhAyVByFACBCBU8pjCS+E="}]},"_npmUser":{"name":"astralarkitekt","email":"Astralarkitekt@gmail.com"},"directories":{},"maintainers":[{"name":"astralarkitekt","email":"Astralarkitekt@gmail.com"}],"_npmOperationalInternal":{"host":"s3://npm-registry-packages-npm-production","tmp":"tmp/tau-tongue_3.9.1_1774132041400_0.5971526631370212"},"_hasShrinkwrap":false}},"time":{"created":"2026-03-02T02:54:46.245Z","modified":"2026-03-21T22:27:21.656Z","3.6.10":"2026-03-02T02:54:46.495Z","3.7.0":"2026-03-03T16:14:21.980Z","3.8.0":"2026-03-14T00:16:15.338Z","3.9.0":"2026-03-21T20:38:26.307Z","3.9.1":"2026-03-21T22:27:21.529Z"},"bugs":{"url":"https://github.com/astralarkitekt/tau-tongue/issues"},"author":{"name":"Astral Arkitekt","email":"astralarkitekt@gmail.com"},"license":"MIT","homepage":"https://github.com/astralarkitekt/tau-tongue#readme","keywords":["symbolic-algebra","narrative-generation","procedural-generation","numerology","pythagorean","storytelling","text-analysis","digital-root","braids","archetypes","config-injectable","tau-tongue","braidcraft"],"repository":{"type":"git","url":"git+https://github.com/astralarkitekt/tau-tongue.git"},"description":"Tau-Tongue is a symbolic narrative algebra for meaning-making and storytelling, designed to help users construct and explore narratives through a structured framework.","maintainers":[{"name":"astralarkitekt","email":"Astralarkitekt@gmail.com"}],"readme":"# @astralarkitekt/tau-tongue\r\n\r\n**A symbolic narrative algebra for meaning-making and storytelling.**\r\n\r\n[![Version](https://img.shields.io/badge/version-3.9.0-blueviolet)]()\r\n[![TypeScript](https://img.shields.io/badge/TypeScript-ESM-blue)]()\r\n\r\n---\r\n\r\n## What Is Tau-Tongue?\r\n\r\nTau-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.\r\n\r\nIt 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.\r\n\r\nAs 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.\r\n\r\n**The constraint doesn't change. The vocabulary does.**\r\n\r\nLearn more about how to use Tau-Tongue on the Astral Architecture blog!\r\n\r\n[Tau-Tongue & Braidcraft: My secret sauce to writing better faster](https://www.astralarchitecture.com/blog/2026/tau-tongue-and-braidcraft/)\r\n\r\nWebsite in the works!\r\n\r\n---\r\n\r\n## Quick Start\r\n\r\n```bash\r\nnpm install @astralarkitekt/tau-tongue\r\n```\r\n\r\n```typescript\r\nimport { TauTongueInterpreter } from '@astralarkitekt/tau-tongue';\r\n\r\nconst interpreter = new TauTongueInterpreter();\r\nconst result = interpreter.interpret('Once upon a time');\r\n\r\nconsole.log(result.archetype);           // \"The Dreamweaver\"\r\nconsole.log(result.resonance);           // \"SOURCE\"\r\nconsole.log(result.symbolicEquation);    // \"∂(1, [∇(3,4),⊗(1,3,9,2,4,4,6), ...])\"\r\nconsole.log(result.crucible);            // \"≳(8) - A mythic potential (≳) acting upon The Mechanist\"\r\nconsole.log(result.narrativeInterpretation);\r\n```\r\n\r\nThe `TauTongueResult` object contains everything: digital root, archetype, resonance, symbolic equation, braid breakdown, crucible, antagonist, inflection points, archetypal matrix, VDS (Variant Density Score), and narrative interpretation.\r\n\r\n---\r\n\r\n## Custom Symbolic Systems\r\n\r\nThe headline feature of v3. Pass a `TauTongueConfig` to the constructor and the entire pipeline adapts:\r\n\r\n```typescript\r\nimport { TauTongueInterpreter, SceneFunction } from '@astralarkitekt/tau-tongue';\r\n\r\nconst jungian = new TauTongueInterpreter({\r\n  archetypeMap: {\r\n    1: 'The Hero',\r\n    2: 'The Shadow',\r\n    3: 'The Anima',\r\n    // ... up to 12\r\n  },\r\n  archetypeDescriptions: {\r\n    'The Hero': 'The conscious ego embarking on the journey...',\r\n    'The Shadow': 'The repressed darkness...',\r\n    // ...\r\n  },\r\n  resonanceMap: {\r\n    1: 'QUEST',\r\n    2: 'REPRESSION',\r\n    3: 'INTUITION',\r\n    // ...\r\n  },\r\n  resonanceDescriptions: {\r\n    'QUEST': 'The call to adventure...',\r\n    // ...\r\n  },\r\n  archetypeFunctionMap: {\r\n    1: SceneFunction.ACTION,\r\n    2: SceneFunction.FLASHBACK,\r\n    // ...\r\n  },\r\n  typalNumbers: [10, 11, 12],\r\n});\r\n\r\nconst result = jungian.interpret('What does the shadow want?');\r\nconsole.log(result.archetype); // A Jungian archetype, not BraidCraft\r\n```\r\n\r\n### TauTongueConfig\r\n\r\nEvery field is optional. Omitted fields fall back to the BraidCraft defaults.\r\n\r\n| Field | Type | Description |\r\n|-------|------|-------------|\r\n| `archetypeMap` | `Record<number, string>` | Digital root → archetype name. Keys define valid reduction endpoints. |\r\n| `archetypeDescriptions` | `Record<string, string>` | Archetype name → prose description. |\r\n| `resonanceMap` | `Record<number, string>` | Digital root → resonance label (e.g. `\"QUEST\"`). |\r\n| `resonanceDescriptions` | `Record<string, string>` | Resonance label → prose description. |\r\n| `archetypeFunctionMap` | `Record<number, SceneFunction>` | Digital root → narrative scene function (used by TauSpine). |\r\n| `symbolMap` | `Record<string, SymbolDefinition>` | Custom operator algebra — symbol → definition. |\r\n| `typalNumbers` | `number[]` | Numbers that halt digital-root reduction (default: `[11, 22]`). |\r\n\r\n### Typal Numbers\r\n\r\nA 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]`.\r\n\r\nSingle-digit numbers (1–9) don't need to be listed — they're natural endpoints by definition.\r\n\r\n### Config-Aware Numerology Mapping\r\n\r\n**New in v3.8.0.** When a custom `archetypeMap` is provided, the interpreter automatically builds a config-derived A-Z mapping by cycling the alphabet over the sorted root set. This means multi-digit values like 10, 11, 12 appear **natively** in the numeroCipher, braids, interference wave, and archetypal matrix — no post-processing required.\r\n\r\nFor example, a Jungian config with archetype keys `[1–12]` produces:\r\n\r\n```\r\nA=1  B=2  C=3  D=4  E=5  F=6  G=7  H=8  I=9  J=10  K=11  L=12\r\nM=1  N=2  O=3  P=4  Q=5  R=6  S=7  T=8  U=9  V=10  W=11  X=12\r\nY=1  Z=2\r\n```\r\n\r\nWhen no custom `archetypeMap` is provided, the traditional Pythagorean mapping (cycling 1–9) is used unchanged. **Default-config behaviour is fully preserved.**\r\n\r\n### Fracticulation\r\n\r\n**New in v3.8.0.** Fracticulation generates variant braids via cipher-cycle evolution. Each braid in a result can branch into up to 3 variants based on its Variant Density Score (VDS) — a measure of pressure density derived from the braid's digit composition.\r\n\r\n```typescript\r\nconst result = interpreter.interpret('Once upon a time');\r\nconst fracticulated = await interpreter.fracticulatize(result);\r\n\r\n// Each braid now has a .variants array and .vds score\r\nfracticulated.braid.forEach(b => {\r\n  console.log(b.equation, b.vds?.variantCount, b.variants?.length);\r\n});\r\n```\r\n\r\nVDS is also computed automatically by `interpret()` and available on `result.vds`.\r\n\r\n---\r\n\r\n## API Reference\r\n\r\n### Core: `TauTongueInterpreter`\r\n\r\n```typescript\r\nconst interpreter = new TauTongueInterpreter(config?: TauTongueConfig);\r\n```\r\n\r\n| Method | Returns | Description |\r\n|--------|---------|-------------|\r\n| `interpret(input)` | `TauTongueResult` | Full pipeline: text → digital root → equation → braid → crucible → narrative. |\r\n| `getCrucible(equation, digitalSum, resonance, archetype)` | `string` | Extract the crucible operator and description from a symbolic equation. |\r\n| `getCrucibleFunction(equation)` | `string` | **New in 3.9.0.** Extract just the crucible operator/function from a symbolic equation. |\r\n| `getMicroCrucible(braidFunction)` | `string` | Get a micro-crucible from a single braid function. |\r\n| `getAntagonist(equation)` | `TauTongueAntagonist` | Extract the antagonist (longest braid) from the symbolic equation. |\r\n| `analyzeInterference(result)` | `InflectionPoint[]` | Locate inflection points between braid functions and the interference wave. |\r\n| `getInterferenceWave(result)` | `number[]` | Calculate the Braid Interference Wave. |\r\n| `extractArchetypalMatrix(equation)` | `ArchetypalMatrix` | Analyze the archetypal distribution of a symbolic equation. |\r\n| `extractNarrativePalette(braid)` | `NarrativePalette` | Analyze the distribution of scene functions across the braid. |\r\n| `calculateVDS(result)` | `VDSResult` | Calculate Variant Density Scores for all braids. |\r\n| `fracticulatize(result)` | `Promise<TauTongueResult>` | Generate braid variants via cipher-cycle fracticulation. |\r\n| `getFunctionDescription(func)` | `string` | Get a prose description for a symbolic function string. |\r\n| `getSymbol(symbol)` | `SymbolDefinition \\| undefined` | Look up a symbol definition from the configured symbol map. |\r\n| `getSymbols()` | `string[]` | Get all symbol keys from the configured symbol map. |\r\n| `render(canvas, result, options?)` | `void` | Render the tau spiral visualization on an HTML canvas. |\r\n\r\n#### Standalone Fracticulation Helpers (New in 3.9.0)\r\n\r\nYou can now use these helpers directly without instantiating the interpreter:\r\n\r\n```typescript\r\nimport { fracticulateBraid, fracticulatize } from '@astralarkitekt/tau-tongue';\r\n\r\nconst braidVariants = await fracticulateBraid('∇(3,4,5)', 3, 7);\r\n// Returns up to 3 braid variants for the given equation and resonance\r\n\r\nconst result = interpreter.interpret('Once upon a time');\r\nconst enriched = await fracticulatize(result);\r\n// Returns a TauTongueResult with .variants arrays on eligible braids\r\n```\r\n\r\n### Legacy Interpreters (v1 & v2)\r\n\r\nThe pre-config-injection interpreters are available under aliased exports for backward compatibility or comparison:\r\n\r\n```typescript\r\nimport { TauTongueInterpreterV1, TauTongueInterpreterV2 } from '@astralarkitekt/tau-tongue';\r\nimport type { TauTongueResultV1, TauTongueResultV2 } from '@astralarkitekt/tau-tongue';\r\n\r\nconst v2 = new TauTongueInterpreterV2();\r\nconst result = v2.interpret('some text'); // Uses hardcoded BraidCraft defaults\r\n```\r\n\r\nThese are frozen at their original implementations — no config injection, no `TauTongueConfig`. Use the primary `TauTongueInterpreter` (v3) for new work.\r\n\r\n### Narrative Structure: `TauSpine`\r\n\r\n`TauSpine` extends `TauTongueInterpreter` and generates recursive narrative trees from interpreted results.\r\n\r\n```typescript\r\nimport { createTauSpine, SpineFormat } from '@astralarkitekt/tau-tongue';\r\n\r\nconst spine = await createTauSpine('Once upon a time', SpineFormat.NOVEL);\r\nconsole.log(spine.spine);  // TauSpineNode[]\r\nconsole.log(spine.stats);  // { totalNodes, maxDepth, generationTime }\r\n\r\n// Or with a custom config:\r\nconst spine = await createTauSpine('Once upon a time', SpineFormat.NOVEL, jungianConfig);\r\n```\r\n\r\n**SpineFormat** determines the narrative scope:\r\n\r\n| Format | Value | Description |\r\n|--------|-------|-------------|\r\n| `SHORT` | 6 | Short story |\r\n| `NOVELETTE` | 7 | Novelette |\r\n| `NOVELLA` | 8 | Novella |\r\n| `NOVEL` | 9 | Novel |\r\n| `EPIC` | 11 | Epic |\r\n| `SAGA` | 22 | Saga |\r\n\r\nSpine results can be flattened to a simple scene list via `spine.flatten()`, and scene paths formatted with `getPath(scene)`.\r\n\r\n### Pythagorean Utilities\r\n\r\nLow-level functions for numerological reduction. These accept an optional `PythagoreanConfig` (derived automatically when using `TauTongueInterpreter`).\r\n\r\n| Function | Description |\r\n|----------|-------------|\r\n| `convertToNumbers(text)` | Convert text to a string of Pythagorean digit values. |\r\n| `calculateDigitalRoot(numStr, config?)` | Reduce a number string to its digital root, respecting typal numbers. |\r\n| `cipherCycle(numeroCipher, resonance, config?)` | Generate a cipher cycle string (async). |\r\n| `extractBraidDigits(equation)` | Extract braid digits from a symbolic equation string. |\r\n| `integerStringFromBase36(bs)` | Convert a base-36 string to its integer representation. |\r\n\r\n### Symbol Algebra\r\n\r\n```typescript\r\nimport { DEFAULT_SYMBOL_MAP } from '@astralarkitekt/tau-tongue';\r\nimport type { SymbolDefinition } from '@astralarkitekt/tau-tongue';\r\n```\r\n\r\nEach `SymbolDefinition` contains:\r\n\r\n| Field | Type | Description |\r\n|-------|------|-------------|\r\n| `name` | `string` | Display name (e.g. \"Partial Derivative\") |\r\n| `mathMeaning` | `string` | Formal mathematical meaning |\r\n| `metaphoricalMeaning` | `string` | Narrative meaning used in interpretation |\r\n\r\n### Phoneme Generation\r\n\r\n```typescript\r\nimport { generatePhonemeticNames } from '@astralarkitekt/tau-tongue';\r\n\r\nconst names = generatePhonemeticNames('12345', 0, 10);\r\n// Returns 10 phonemic word variations derived from the numerocipher\r\n```\r\n\r\n### Default Constants\r\n\r\nAll BraidCraft defaults are available as named exports:\r\n\r\n- `DEFAULT_ARCHETYPE_MAP`\r\n- `DEFAULT_ARCHETYPE_DESCRIPTIONS`\r\n- `DEFAULT_RESONANCE_MAP`\r\n- `DEFAULT_RESONANCE_DESCRIPTIONS`\r\n- `DEFAULT_ARCHETYPE_FUNCTION_MAP`\r\n- `DEFAULT_SYMBOL_MAP`\r\n- `DEFAULT_TYPAL_NUMBERS`\r\n\r\n### Types\r\n\r\nAll TypeScript types are exported:\r\n\r\n```typescript\r\nimport type {\r\n  TauTongueConfig,\r\n  TauTongueResult,\r\n  TauTongueAntagonist,\r\n  BraidInterpretation,\r\n  InflectionPoint,\r\n  NarrativePalette,\r\n  RenderOptions,\r\n  PythagoreanConfig,\r\n  SymbolDefinition,\r\n  TauSpineNode,\r\n  TauSpineResult,\r\n  FlattenedTauSpineResult,\r\n  FlattenedScene,\r\n  ArchetypalMatrix,\r\n  ArchetypalEntry,\r\n  VDSResult,\r\n  BraidVariantScore,\r\n  BraidVariant,\r\n  FormatData,\r\n  UnitSpec,\r\n} from '@astralarkitekt/tau-tongue';\r\n```\r\n\r\n---\r\n\r\n## Demo Gallery\r\n\r\nLive demos at [tools.astralarchitecture.com/tau-tongue](https://tools.astralarchitecture.com/tau-tongue/):\r\n\r\n| Demo | Description |\r\n|------|-------------|\r\n| [Interpreter](https://tools.astralarchitecture.com/tau-tongue/demos/interpreter.html) | Full result workbench — digital root, archetype, equation, braid, crucible, narrative. |\r\n| [Spine Generator](https://tools.astralarchitecture.com/tau-tongue/demos/spine-generator.html) | Recursive `TauSpine` tree visualization from input text. |\r\n| [TauFracticulate](https://tools.astralarchitecture.com/tau-tongue/demos/TauFracticulate.html) | Fracticulation explorer — VDS scoring, braid variants, cipher-cycle evolution. |\r\n| [TauSigils](https://tools.astralarchitecture.com/tau-tongue/demos/TauSigils.html) | Ethereal continuous-line sigil drawings from braid structure. |\r\n| [TauGlyphs](https://tools.astralarchitecture.com/tau-tongue/demos/TauGlyphs.html) | Colored node graphs showing structural braid relationships. |\r\n| [TauAlchemy](https://tools.astralarchitecture.com/tau-tongue/demos/TauAlchemy.html) | Animated alchemical seal geometry driven by braid data. |\r\n| [TauAstrolabe](https://tools.astralarchitecture.com/tau-tongue/demos/TauAstrolabe.html) | Alchemical system (v3 config) — celestial orbit visualization. |\r\n| [TauAether](https://tools.astralarchitecture.com/tau-tongue/demos/TauAether.html) | Norse Runic system (v3 config) — organic aether energy fields. |\r\n| [Jung-Tongue](https://tools.astralarchitecture.com/tau-tongue/demos/JungTongue.html) | Jungian chatbot — 12 archetypes, session persistence, voice input. |\r\n\r\n---\r\n\r\n## Project Structure\r\n\r\n```\r\nsrc/\r\n  index.ts                          # Public API re-exports\r\n  pythagoreanUtils.ts               # Numerological reduction utilities\r\n  phonemeCipher.ts                  # Phonemic name generation\r\n  tau-tongue/\r\n    TauTongueInterpreter_v3.ts      # Core interpreter — config-injectable (v3)\r\n    TauTongueInterpreter_v2.ts      # Legacy interpreter (v2, pre-config)\r\n    TauTongueInterpreter_v1.ts      # Legacy interpreter (v1)\r\n    TauSpine.ts                     # Recursive narrative structure generator\r\n    TauTongueSymbolMap.ts           # 256-operator symbol algebra\r\n    TauTongueRenderer.ts            # Canvas spiral renderer\r\n    TauTongueFictionTypeMap.ts      # Fiction type classification\r\n    TauTomeCoverRenderer.ts         # Book cover generation\r\n    symbol-map.json                 # Symbol definitions data\r\n    archetype-fiction-type-map.json  # Archetype → fiction type mapping\r\n    story-unit-specs.json           # Narrative unit specifications\r\ndemos/\r\n  interpreter.html                  # Full result workbench\r\n  spine-generator.html              # TauSpine tree visualizer\r\n  TauFracticulate.html              # Fracticulation / VDS explorer\r\n  TauSigils.html                    # Sigil art renderer\r\n  TauGlyphs.html                    # Glyph graph renderer\r\n  TauAlchemy.html                   # Alchemical seal geometry\r\n  TauAstrolabe.html                 # Alchemical config demo (v3)\r\n  TauAether.html                    # Norse Runic config demo (v3)\r\n  JungTongue.html                   # Jungian chatbot demo\r\n  jung-tongue-config.js             # Jungian symbolic system config\r\nsimulations/\r\n  fracticulate.ts                   # VDS distribution simulation (10k epochs)\r\n  jung-interference-test.ts         # Multi-digit config verification tests\r\n```\r\n\r\n---\r\n\r\n## Development\r\n\r\n```bash\r\ngit clone https://github.com/astralarkitekt/tau-tongue.git\r\ncd tau-tongue\r\nnpm install\r\nnpm run build          # Compiles TypeScript to dist/\r\n```\r\n\r\nDemos load from `../dist/index.js` as ES modules — open any HTML file in `demos/` after building.\r\n\r\n---\r\n\r\n## Author\r\n\r\n**Astral Arkitekt** — [astralarkitekt@gmail.com](mailto:astralarkitekt@gmail.com)\r\n\r\nBuilt with deterministic algebra, insomnia, and an unreasonable amount of love. I mean coffee.\r\n","readmeFilename":"README.md"}