{"_id":"alvamind","_rev":"11-9ebab0aabffe3545dc16a319fa412776","name":"alvamind","dist-tags":{"latest":"1.0.13"},"versions":{"1.0.1":{"name":"alvamind","version":"1.0.1","keywords":["state-management","dependency-injection","typescript","fp-ts"],"author":{"name":"Alvamind"},"license":"MIT","_id":"alvamind@1.0.1","maintainers":[{"name":"alvamind","email":"alvaminddigital@gmail.com"}],"homepage":"https://github.com/alvamind/alvamind#readme","bugs":{"url":"https://github.com/alvamind/alvamind/issues"},"dist":{"shasum":"6b243da874cf541fd4bcefb3774602e9542c5d0f","tarball":"https://registry.npmjs.org/alvamind/-/alvamind-1.0.1.tgz","fileCount":46,"integrity":"sha512-nSpq2iA0EagnWCwQxFWb7PpZIdERiwWsBSZKIcvAl2+ijcqwATPMVYOaannOxLeVw6TGV1GnLUqs5c5GcdJzPg==","signatures":[{"sig":"MEUCIBsZjBwaR3KboMX3gaIqOWgHwme6AevnCWtiYmfm7KZOAiEApOpIBPtE+jQ3tN3tX2SlNonWfRzxK7kRC1QyJTYoBR8=","keyid":"SHA256:DhQ8wR5APBvFHLF/+Tc+AYvPOdTpcIDqOhxsBHRwC7U"}],"unpackedSize":72503},"main":"dist/index.js","type":"module","types":"dist/index.d.ts","exports":{".":{"types":"./dist/index.d.ts","import":"./dist/index.js"}},"gitHead":"24807dc8f252a0d69a5c6aafba59d6b5b1cd59a2","scripts":{"build":"tsc -p tsconfig.build.json","clean":"clean","commit":"commit","source":"generate-source output=documentation.md exclude=dist/,node_modules/,.git/","patch:undo":"find . -type f -name \"*.ts\" -delete && find . -type f -name \"*.ts.orig\" -exec sh -c 'mv \"$0\" \"$(dirname \"$0\")/$(basename \"$0\" .orig)\"' \\;","split-code":"split-code source=combined.ts markers=src/,lib/ outputDir=./output","patch:apply":"patch -p2 -F3 -b < patch.diff","publish-npm":"publish-npm patch","patch:del-ori":"find . -type f -name \"*.ts.orig\" -delete"},"_npmUser":{"name":"alvamind","email":"alvaminddigital@gmail.com"},"repository":{"url":"git+https://github.com/alvamind/alvamind.git","type":"git"},"_npmVersion":"9.2.0","description":"automatically create TypeScript interfaces and types that mirror your Prisma schema models and enums","directories":{},"_nodeVersion":"20.16.0","dependencies":{"fp-ts":"2.16.9","alvamind-tools":"^1.0.23"},"_hasShrinkwrap":false,"devDependencies":{"@types/bun":"latest"},"peerDependencies":{"typescript":"^5.0.0"},"_npmOperationalInternal":{"tmp":"tmp/alvamind_1.0.1_1739335138182_0.31974521881959284","host":"s3://npm-registry-packages-npm-production"}},"1.0.2":{"name":"alvamind","version":"1.0.2","keywords":["state-management","dependency-injection","typescript","fp-ts"],"author":{"name":"Alvamind"},"license":"MIT","_id":"alvamind@1.0.2","maintainers":[{"name":"alvamind","email":"alvaminddigital@gmail.com"}],"homepage":"https://github.com/alvamind/alvamind-ts#readme","bugs":{"url":"https://github.com/alvamind/alvamind-ts/issues"},"dist":{"shasum":"82a3e5219422f86e0e29fe33c880cc960ccf7b00","tarball":"https://registry.npmjs.org/alvamind/-/alvamind-1.0.2.tgz","fileCount":46,"integrity":"sha512-0AzGKYNLAHptBmn17gC2T0bIX9/Z96JjTNDx582Vn0V362z8lyHmmxilK9+xkT6vrKv7XMvjKz5C986GhqpYxQ==","signatures":[{"sig":"MEUCIQDFTx6QjJkfZy5HyWgSXQz6DCN8YKiFub87/32+afFNPAIgf11yB8/SgxXqNmDEZxLy57kTeX5o4pwW8IvgeERENBU=","keyid":"SHA256:DhQ8wR5APBvFHLF/+Tc+AYvPOdTpcIDqOhxsBHRwC7U"}],"unpackedSize":72486},"main":"dist/index.js","type":"module","types":"dist/index.d.ts","exports":{".":{"types":"./dist/index.d.ts","import":"./dist/index.js"}},"gitHead":"7f19a166cacdd73bf6811e6c70d3dd5046ac6f34","scripts":{"build":"tsc -p tsconfig.build.json","clean":"clean","commit":"commit","source":"generate-source output=documentation.md exclude=dist/,node_modules/,.git/","patch:undo":"find . -type f -name \"*.ts\" -delete && find . -type f -name \"*.ts.orig\" -exec sh -c 'mv \"$0\" \"$(dirname \"$0\")/$(basename \"$0\" .orig)\"' \\;","split-code":"split-code source=combined.ts markers=src/,lib/ outputDir=./output","patch:apply":"patch -p2 -F3 -b < patch.diff","publish-npm":"publish-npm patch","patch:del-ori":"find . -type f -name \"*.ts.orig\" -delete"},"_npmUser":{"name":"alvamind","email":"alvaminddigital@gmail.com"},"repository":{"url":"git+https://github.com/alvamind/alvamind-ts.git","type":"git"},"_npmVersion":"9.2.0","description":"automatically create TypeScript interfaces and types that mirror your Prisma schema models and enums","directories":{},"_nodeVersion":"20.16.0","dependencies":{"fp-ts":"2.16.9","alvamind-tools":"^1.0.23"},"_hasShrinkwrap":false,"devDependencies":{"@types/bun":"latest"},"peerDependencies":{"typescript":"^5.0.0"},"_npmOperationalInternal":{"tmp":"tmp/alvamind_1.0.2_1739335921364_0.3116584281248982","host":"s3://npm-registry-packages-npm-production"}},"1.0.3":{"name":"alvamind","version":"1.0.3","keywords":["state-management","dependency-injection","typescript","fp-ts"],"author":{"name":"Alvamind"},"license":"MIT","_id":"alvamind@1.0.3","maintainers":[{"name":"alvamind","email":"alvaminddigital@gmail.com"}],"homepage":"https://github.com/alvamind/alvamind-ts#readme","bugs":{"url":"https://github.com/alvamind/alvamind-ts/issues"},"dist":{"shasum":"704b277ad87c4727d901050d932c869cbc36a65b","tarball":"https://registry.npmjs.org/alvamind/-/alvamind-1.0.3.tgz","fileCount":46,"integrity":"sha512-hJ5I3StwKMIb73fcNwjjK/i08GubnCAYBFlXu/B9tjYoXot34rf0l4MNna19RWtB8N8gvYL4MHcDY2vvANikEQ==","signatures":[{"sig":"MEUCIQC8sAgAzUSlzFaxr/Tm3scq1a3m1JyBveo/8f0d+bmWmAIgTMNtYFae4rbFXcUkwfOm8j08V8yKxAfsEnGrfP6oEXU=","keyid":"SHA256:DhQ8wR5APBvFHLF/+Tc+AYvPOdTpcIDqOhxsBHRwC7U"}],"unpackedSize":72962},"main":"dist/index.js","type":"module","types":"dist/index.d.ts","exports":{".":{"types":"./dist/index.d.ts","import":"./dist/index.js"}},"gitHead":"370548b34f81ad96685e4a3cbcfd4974ebf96f1d","scripts":{"build":"tsc -p tsconfig.build.json","clean":"clean","commit":"commit","source":"generate-source output=documentation.md exclude=dist/,node_modules/,.git/","patch:undo":"find . -type f -name \"*.ts\" -delete && find . -type f -name \"*.ts.orig\" -exec sh -c 'mv \"$0\" \"$(dirname \"$0\")/$(basename \"$0\" .orig)\"' \\;","split-code":"split-code source=combined.ts markers=src/,lib/ outputDir=./output","patch:apply":"patch -p2 -F3 -b < patch.diff","publish-npm":"publish-npm patch","patch:del-ori":"find . -type f -name \"*.ts.orig\" -delete"},"_npmUser":{"name":"alvamind","email":"alvaminddigital@gmail.com"},"repository":{"url":"git+https://github.com/alvamind/alvamind-ts.git","type":"git"},"_npmVersion":"9.2.0","description":"automatically create TypeScript interfaces and types that mirror your Prisma schema models and enums","directories":{},"_nodeVersion":"20.16.0","dependencies":{"fp-ts":"2.16.9","alvamind-tools":"^1.0.23"},"_hasShrinkwrap":false,"devDependencies":{"@types/bun":"latest"},"peerDependencies":{"typescript":"^5.0.0"},"_npmOperationalInternal":{"tmp":"tmp/alvamind_1.0.3_1739337089919_0.5219895130806649","host":"s3://npm-registry-packages-npm-production"}},"1.0.4":{"name":"alvamind","version":"1.0.4","keywords":["state-management","dependency-injection","typescript","fp-ts"],"author":{"name":"Alvamind"},"license":"MIT","_id":"alvamind@1.0.4","maintainers":[{"name":"alvamind","email":"alvaminddigital@gmail.com"}],"homepage":"https://github.com/alvamind/alvamind-ts#readme","bugs":{"url":"https://github.com/alvamind/alvamind-ts/issues"},"dist":{"shasum":"a6f01ba933b3d4b2163f8c019044e4ba3db00334","tarball":"https://registry.npmjs.org/alvamind/-/alvamind-1.0.4.tgz","fileCount":10,"integrity":"sha512-GgiK+zouE/sXyXXzmVaz49I62HDDCVYi6ptFmGCBO8vreoNxQEUda7miTS30LAxQ9ic8YAH0x7jtj4CskV3Fwg==","signatures":[{"sig":"MEUCIQClSXFxuTt2bA2STE5IcVK5CM7sHkdDkEtRGWHe6hhU7AIgAIjI3qAQhCJexhjwxuBggoij9bzf+2JbPNdt9VKHrck=","keyid":"SHA256:DhQ8wR5APBvFHLF/+Tc+AYvPOdTpcIDqOhxsBHRwC7U"}],"unpackedSize":55445},"main":"dist/index.js","type":"module","types":"dist/index.d.ts","exports":{".":{"types":"./dist/index.d.ts","import":"./dist/index.js"}},"gitHead":"3bf434f3a2a6dd69bfc38553dd4cddee6b199bff","scripts":{"build":"tsc -p tsconfig.build.json","clean":"clean","commit":"commit","source":"generate-source output=documentation.md exclude=dist/,node_modules/,.git/","patch:undo":"find . -type f -name \"*.ts\" -delete && find . -type f -name \"*.ts.orig\" -exec sh -c 'mv \"$0\" \"$(dirname \"$0\")/$(basename \"$0\" .orig)\"' \\;","split-code":"split-code source=combined.ts markers=src/,lib/ outputDir=./output","patch:apply":"patch -p2 -F3 -b < patch.diff","publish-npm":"publish-npm patch","patch:del-ori":"find . -type f -name \"*.ts.orig\" -delete"},"_npmUser":{"name":"alvamind","email":"alvaminddigital@gmail.com"},"repository":{"url":"git+https://github.com/alvamind/alvamind-ts.git","type":"git"},"_npmVersion":"9.2.0","description":"automatically create TypeScript interfaces and types that mirror your Prisma schema models and enums","directories":{},"_nodeVersion":"20.16.0","dependencies":{"fp-ts":"2.16.9","elysia":"^1.2.12","alvamind":"^1.0.3","@elysiajs/eden":"^1.2.0","alvamind-tools":"^1.0.23"},"_hasShrinkwrap":false,"devDependencies":{"tinybench":"^3.1.1","@types/bun":"latest"},"peerDependencies":{"typescript":"^5.0.0"},"_npmOperationalInternal":{"tmp":"tmp/alvamind_1.0.4_1739523926836_0.27072413812287555","host":"s3://npm-registry-packages-npm-production"}},"1.0.5":{"name":"alvamind","version":"1.0.5","keywords":["state-management","typescript"],"author":"","license":"MIT","_id":"alvamind@1.0.5","maintainers":[{"name":"alvamind","email":"alvaminddigital@gmail.com"}],"homepage":"https://github.com/alvamind/alvamind-ts#readme","bugs":{"url":"https://github.com/alvamind/alvamind-ts/issues"},"dist":{"shasum":"19bcb5a840dc69fce6b9ab5b6c6a5aec7c9c5e09","tarball":"https://registry.npmjs.org/alvamind/-/alvamind-1.0.5.tgz","fileCount":10,"integrity":"sha512-sKY+hg1ylk4GGc+nnZTLNGpmfpcD9YnWlW0Y4e35yAmpmw+9kfOrLF3h8HTfYGBrSfzmAKnCLNN/MrTr35g28g==","signatures":[{"sig":"MEUCIQCoyBOfNjTO7fqGjgs14aE2gr7KQAkxdU6pd2btkGlcegIgAw+buENi+rA6/YfAPdw2a1tIyyk7/bMwpfgDS97UKOM=","keyid":"SHA256:DhQ8wR5APBvFHLF/+Tc+AYvPOdTpcIDqOhxsBHRwC7U"}],"unpackedSize":56819},"main":"dist/index.js","type":"module","types":"dist/index.d.ts","exports":{".":{"types":"./dist/index.d.ts","import":"./dist/index.js"}},"gitHead":"09c3229e8be8d14c4f124a1b2233495583bd20db","scripts":{"build":"tsc -p tsconfig.build.json","clean":"clean","commit":"commit","source":"generate-source output=documentation.md exclude=dist/,node_modules/,.git/","patch:undo":"find . -type f -name \"*.ts\" -delete && find . -type f -name \"*.ts.orig\" -exec sh -c 'mv \"$0\" \"$(dirname \"$0\")/$(basename \"$0\" .orig)\"' \\;","split-code":"split-code source=combined.ts markers=src/,lib/ outputDir=./output","patch:apply":"patch -p2 -F3 -b < patch.diff","publish-npm":"publish-npm patch","patch:del-ori":"find . -type f -name \"*.ts.orig\" -delete"},"_npmUser":{"name":"alvamind","email":"alvaminddigital@gmail.com"},"repository":{"url":"git+https://github.com/alvamind/alvamind-ts.git","type":"git"},"_npmVersion":"9.2.0","description":"A lightweight state management library","directories":{},"_nodeVersion":"20.16.0","dependencies":{"fp-ts":"2.16.9","elysia":"^1.2.12","alvamind":"^1.0.3","@elysiajs/eden":"^1.2.0","alvamind-tools":"^1.0.23"},"_hasShrinkwrap":false,"devDependencies":{"tinybench":"^3.1.1","@types/bun":"latest","typescript":"^4.9.0"},"peerDependencies":{"typescript":"^5.0.0"},"_npmOperationalInternal":{"tmp":"tmp/alvamind_1.0.5_1739524562497_0.5639919738070232","host":"s3://npm-registry-packages-npm-production"}},"1.0.6":{"name":"alvamind","version":"1.0.6","keywords":["state-management","typescript"],"author":"","license":"MIT","_id":"alvamind@1.0.6","maintainers":[{"name":"alvamind","email":"alvaminddigital@gmail.com"}],"homepage":"https://github.com/alvamind/alvamind-ts#readme","bugs":{"url":"https://github.com/alvamind/alvamind-ts/issues"},"dist":{"shasum":"1971e9b486b6079ce5342cc444bd8f1feef387ce","tarball":"https://registry.npmjs.org/alvamind/-/alvamind-1.0.6.tgz","fileCount":10,"integrity":"sha512-T2noJCaFO6S3vS9xXbWwg5Nht3LzXCSzedsHy316x9lh3xjpcU2TwjZWj5PpeVI1fNeGPG/6gPsLG7CdV7lWLA==","signatures":[{"sig":"MEUCIQC0n95KdSzocVY56xJKGMkWJfUGiC7vzDxL5Gw7r+kaVAIgXvuICKlAzlw50o08sxhAIDd/JxHIemfPXO8CzmkCspQ=","keyid":"SHA256:DhQ8wR5APBvFHLF/+Tc+AYvPOdTpcIDqOhxsBHRwC7U"}],"unpackedSize":55810},"main":"dist/index.js","type":"module","types":"dist/index.d.ts","exports":{".":{"types":"./dist/index.d.ts","import":"./dist/index.js"}},"gitHead":"b82647c95ffb38f99bc98889b17cab4993cdb263","scripts":{"build":"tsc -p tsconfig.build.json","clean":"clean","commit":"commit","source":"generate-source output=documentation.md exclude=dist/,node_modules/,.git/","patch:undo":"find . -type f -name \"*.ts\" -delete && find . -type f -name \"*.ts.orig\" -exec sh -c 'mv \"$0\" \"$(dirname \"$0\")/$(basename \"$0\" .orig)\"' \\;","split-code":"split-code source=combined.ts markers=src/,lib/ outputDir=./output","patch:apply":"patch -p2 -F3 -b < patch.diff","publish-npm":"publish-npm patch","patch:del-ori":"find . -type f -name \"*.ts.orig\" -delete"},"_npmUser":{"name":"alvamind","email":"alvaminddigital@gmail.com"},"repository":{"url":"git+https://github.com/alvamind/alvamind-ts.git","type":"git"},"_npmVersion":"9.2.0","description":"A lightweight state management library","directories":{},"_nodeVersion":"20.16.0","dependencies":{"fp-ts":"2.16.9","elysia":"^1.2.12","alvamind":"^1.0.3","@elysiajs/eden":"^1.2.0","alvamind-tools":"^1.0.23"},"_hasShrinkwrap":false,"devDependencies":{"tinybench":"^3.1.1","@types/bun":"latest","typescript":"^4.9.0"},"peerDependencies":{"typescript":"^5.0.0"},"_npmOperationalInternal":{"tmp":"tmp/alvamind_1.0.6_1739550350204_0.005124620548601744","host":"s3://npm-registry-packages-npm-production"}},"1.0.7":{"name":"alvamind","version":"1.0.7","keywords":["state-management","typescript"],"author":"","license":"MIT","_id":"alvamind@1.0.7","maintainers":[{"name":"alvamind","email":"alvaminddigital@gmail.com"}],"homepage":"https://github.com/alvamind/alvamind-ts#readme","bugs":{"url":"https://github.com/alvamind/alvamind-ts/issues"},"dist":{"shasum":"45bdd2823c7b0d15c35cbe2eea19701e036fa9d2","tarball":"https://registry.npmjs.org/alvamind/-/alvamind-1.0.7.tgz","fileCount":10,"integrity":"sha512-lcOuqLNM+UQ9DQRZYiFSxjKywFY2Vmw/bZnHkkZZyUkvK1mdO603YulLPhxJE+HUYY363khgq+E5jxm1C4QjZA==","signatures":[{"sig":"MEYCIQDIH+2MVbumcIDHZm9FDAl20mLyYApCRKpUSocqdbNLNgIhAN+b10nKP0MmU87++TQSxYWIrAHl9AI7uUKa2jvRsVPM","keyid":"SHA256:DhQ8wR5APBvFHLF/+Tc+AYvPOdTpcIDqOhxsBHRwC7U"}],"unpackedSize":59143},"main":"dist/index.js","type":"module","types":"dist/index.d.ts","exports":{".":{"types":"./dist/index.d.ts","import":"./dist/index.js"}},"gitHead":"74e3f1f196abe1f2c94f7210b1f0676adfc4b8ec","scripts":{"build":"tsc -p tsconfig.build.json","clean":"clean","commit":"commit","source":"generate-source output=documentation.md exclude=dist/,node_modules/,.git/","patch:undo":"find . -type f -name \"*.ts\" -delete && find . -type f -name \"*.ts.orig\" -exec sh -c 'mv \"$0\" \"$(dirname \"$0\")/$(basename \"$0\" .orig)\"' \\;","split-code":"split-code source=combined.ts markers=src/,lib/ outputDir=./output","patch:apply":"patch -p2 -F3 -b < patch.diff","publish-npm":"publish-npm patch","patch:del-ori":"find . -type f -name \"*.ts.orig\" -delete"},"_npmUser":{"name":"alvamind","email":"alvaminddigital@gmail.com"},"repository":{"url":"git+https://github.com/alvamind/alvamind-ts.git","type":"git"},"_npmVersion":"9.2.0","description":"A lightweight state management library","directories":{},"_nodeVersion":"20.16.0","dependencies":{"fp-ts":"2.16.9","elysia":"^1.2.12","alvamind":"^1.0.3","@elysiajs/eden":"^1.2.0","alvamind-tools":"^1.0.23"},"_hasShrinkwrap":false,"devDependencies":{"tinybench":"^3.1.1","@types/bun":"latest","typescript":"^4.9.0"},"peerDependencies":{"typescript":"^5.0.0"},"_npmOperationalInternal":{"tmp":"tmp/alvamind_1.0.7_1739604969915_0.5715177938603118","host":"s3://npm-registry-packages-npm-production"}},"1.0.9":{"name":"alvamind","version":"1.0.9","keywords":["state-management","typescript"],"author":"","license":"MIT","_id":"alvamind@1.0.9","maintainers":[{"name":"alvamind","email":"alvaminddigital@gmail.com"}],"homepage":"https://github.com/alvamind/alvamind-ts#readme","bugs":{"url":"https://github.com/alvamind/alvamind-ts/issues"},"dist":{"shasum":"57511f28f60bc9ae6da668a281be0f2c5dbcc877","tarball":"https://registry.npmjs.org/alvamind/-/alvamind-1.0.9.tgz","fileCount":10,"integrity":"sha512-IjI9XnINS1d/bjSbgbdmrk607IUjmXwXdxWsANt8rUPVY932nb5nE3k0rG7oLVamnbadhAB7oVKf2Ze3DSzdNg==","signatures":[{"sig":"MEUCIQCGj4z75N5H0chyL7w44aVL0fCza8Lvh7e08TDWLVazMgIgQJqXAtLe35SDkontSsNlXBhPCowiF4f7Yl3rch9W8lU=","keyid":"SHA256:DhQ8wR5APBvFHLF/+Tc+AYvPOdTpcIDqOhxsBHRwC7U"}],"unpackedSize":59251},"main":"dist/index.js","type":"module","types":"dist/index.d.ts","exports":{".":{"types":"./dist/index.d.ts","import":"./dist/index.js"}},"gitHead":"f0e3b877cea803e81b7dc48f43338631f9a6dbcc","scripts":{"build":"tsc -p tsconfig.build.json","clean":"clean","commit":"commit","source":"generate-source output=documentation.md exclude=dist/,node_modules/,.git/","patch:undo":"find . -type f -name \"*.ts\" -delete && find . -type f -name \"*.ts.orig\" -exec sh -c 'mv \"$0\" \"$(dirname \"$0\")/$(basename \"$0\" .orig)\"' \\;","split-code":"split-code source=combined.ts markers=src/,lib/ outputDir=./output","patch:apply":"patch -p2 -F3 -b < patch.diff","publish-npm":"publish-npm patch","patch:del-ori":"find . -type f -name \"*.ts.orig\" -delete"},"_npmUser":{"name":"alvamind","email":"alvaminddigital@gmail.com"},"repository":{"url":"git+https://github.com/alvamind/alvamind-ts.git","type":"git"},"_npmVersion":"9.2.0","description":"A lightweight state management library","directories":{},"_nodeVersion":"20.16.0","dependencies":{"fp-ts":"2.16.9","elysia":"^1.2.12","alvamind":"^1.0.3","@elysiajs/eden":"^1.2.0","alvamind-tools":"^1.0.23"},"_hasShrinkwrap":false,"devDependencies":{"tinybench":"^3.1.1","@types/bun":"latest","typescript":"^4.9.0"},"peerDependencies":{"typescript":"^5.0.0"},"_npmOperationalInternal":{"tmp":"tmp/alvamind_1.0.9_1739616714119_0.9707992073092613","host":"s3://npm-registry-packages-npm-production"}},"1.0.10":{"name":"alvamind","version":"1.0.10","keywords":["state-management","typescript"],"author":"","license":"MIT","_id":"alvamind@1.0.10","maintainers":[{"name":"alvamind","email":"alvaminddigital@gmail.com"}],"homepage":"https://github.com/alvamind/alvamind-ts#readme","bugs":{"url":"https://github.com/alvamind/alvamind-ts/issues"},"dist":{"shasum":"e5a864b4502247a5c9a574184439b2a0a8901867","tarball":"https://registry.npmjs.org/alvamind/-/alvamind-1.0.10.tgz","fileCount":10,"integrity":"sha512-E7VX42DfHPoepUBfcDlnKOEer1+II1bH+54F2vx7HI/kDD/ZTeSrhEyeg9MtEc7riZ/y15nN2bZ5AKg9VaMFjw==","signatures":[{"sig":"MEUCIGWtU0oHSkb9qe2ITBow5GNT1i3oHbNJK8RlC8elvqBlAiEA8GtAB8Rvd9ArsPICra2UMXD2xHdcpX29N2UBW8kvH7o=","keyid":"SHA256:DhQ8wR5APBvFHLF/+Tc+AYvPOdTpcIDqOhxsBHRwC7U"}],"unpackedSize":62271},"main":"dist/index.js","type":"module","types":"dist/index.d.ts","exports":{".":{"types":"./dist/index.d.ts","import":"./dist/index.js"}},"gitHead":"bddef480a01e66972f22690ad2cad7b6e78bfd1f","scripts":{"build":"tsc -p tsconfig.build.json","clean":"clean","commit":"commit","source":"generate-source output=documentation.md exclude=dist/,node_modules/,.git/","patch:undo":"find . -type f -name \"*.ts\" -delete && find . -type f -name \"*.ts.orig\" -exec sh -c 'mv \"$0\" \"$(dirname \"$0\")/$(basename \"$0\" .orig)\"' \\;","split-code":"split-code source=combined.ts markers=src/,lib/ outputDir=./output","patch:apply":"patch -p2 -F3 -b < patch.diff","publish-npm":"publish-npm patch","patch:del-ori":"find . -type f -name \"*.ts.orig\" -delete"},"_npmUser":{"name":"alvamind","email":"alvaminddigital@gmail.com"},"repository":{"url":"git+https://github.com/alvamind/alvamind-ts.git","type":"git"},"_npmVersion":"9.2.0","description":"A lightweight state management library","directories":{},"_nodeVersion":"20.16.0","dependencies":{"fp-ts":"2.16.9","elysia":"^1.2.12","alvamind":"^1.0.3","@elysiajs/eden":"^1.2.0","alvamind-tools":"^1.0.23"},"_hasShrinkwrap":false,"devDependencies":{"tinybench":"^3.1.1","@types/bun":"latest","typescript":"^4.9.0"},"peerDependencies":{"typescript":"^5.0.0"},"_npmOperationalInternal":{"tmp":"tmp/alvamind_1.0.10_1739624750447_0.8289368712475607","host":"s3://npm-registry-packages-npm-production"}},"1.0.11":{"name":"alvamind","version":"1.0.11","keywords":["state-management","typescript"],"author":"","license":"MIT","_id":"alvamind@1.0.11","maintainers":[{"name":"alvamind","email":"alvaminddigital@gmail.com"}],"homepage":"https://github.com/alvamind/alvamind-ts#readme","bugs":{"url":"https://github.com/alvamind/alvamind-ts/issues"},"dist":{"shasum":"eb72ae157c25580d0ecea34aa9e3877baf5ad3f2","tarball":"https://registry.npmjs.org/alvamind/-/alvamind-1.0.11.tgz","fileCount":10,"integrity":"sha512-QUjil/Eth6G9cy6Bu774slCeiqrIdLHwnKq9YURlDkeCB7DrM+kh8l0IZO8dGxPj+QaVaEKYov6m9M2xvRhvAw==","signatures":[{"sig":"MEUCID2Cs7fUaZn044X6KerXS4NW/mKWGMYKauxh+uRA1K5GAiEA04J8ZKSpWk4F7AYatnVq/S8NJv+6XwOACJmEWT/9Kv0=","keyid":"SHA256:DhQ8wR5APBvFHLF/+Tc+AYvPOdTpcIDqOhxsBHRwC7U"}],"unpackedSize":62429},"main":"dist/index.js","type":"module","types":"dist/index.d.ts","exports":{".":{"types":"./dist/index.d.ts","import":"./dist/index.js"}},"gitHead":"e21aa3ef3a6ed8ac7ffa2bd0da62ffce67ab3d87","scripts":{"build":"tsc -p tsconfig.build.json","clean":"clean","commit":"commit","source":"generate-source output=documentation.md exclude=dist/,node_modules/,.git/","patch:undo":"find . -type f -name \"*.ts\" -delete && find . -type f -name \"*.ts.orig\" -exec sh -c 'mv \"$0\" \"$(dirname \"$0\")/$(basename \"$0\" .orig)\"' \\;","split-code":"split-code source=combined.ts markers=src/,lib/ outputDir=./output","patch:apply":"patch -p2 -F3 -b < patch.diff","publish-npm":"publish-npm patch","patch:del-ori":"find . -type f -name \"*.ts.orig\" -delete"},"_npmUser":{"name":"alvamind","email":"alvaminddigital@gmail.com"},"repository":{"url":"git+https://github.com/alvamind/alvamind-ts.git","type":"git"},"_npmVersion":"9.2.0","description":"A lightweight state management library","directories":{},"_nodeVersion":"20.16.0","dependencies":{"alvamind-tools":"^1.0.23"},"_hasShrinkwrap":false,"devDependencies":{"tinybench":"^3.1.1","@types/bun":"latest","typescript":"^5.7.3"},"peerDependencies":{"typescript":"^5.0.0"},"_npmOperationalInternal":{"tmp":"tmp/alvamind_1.0.11_1739795939876_0.3965353839861028","host":"s3://npm-registry-packages-npm-production"}},"1.0.12":{"name":"alvamind","version":"1.0.12","keywords":["state-management","typescript"],"author":"","license":"MIT","_id":"alvamind@1.0.12","maintainers":[{"name":"alvamind","email":"alvaminddigital@gmail.com"}],"homepage":"https://github.com/alvamind/alvamind-ts#readme","bugs":{"url":"https://github.com/alvamind/alvamind-ts/issues"},"dist":{"shasum":"efc4acd51e6ff28672d2915522062a6a6d67eb6a","tarball":"https://registry.npmjs.org/alvamind/-/alvamind-1.0.12.tgz","fileCount":10,"integrity":"sha512-sqXiRLpyHK7GHCae0fojtwgsUzJl6mVPJHZlyn2Fj4eJSAxlI7LkX1GncdeSRxr14nzwRsXcp39Ihy7SZGc5Xw==","signatures":[{"sig":"MEUCIEhdP7FC/v8HglrVWMRa8Tevc9YJpyVBU84JhUnBgs8qAiEA089Vr/D8B4DvuLK6OvuWENHB/Xyb6v+BHMZ1ZFpfTyM=","keyid":"SHA256:DhQ8wR5APBvFHLF/+Tc+AYvPOdTpcIDqOhxsBHRwC7U"}],"unpackedSize":62500},"main":"./dist/index.js","type":"module","types":"./dist/index.d.ts","module":"./dist/index.js","exports":{".":{"types":"./dist/index.d.ts","import":"./dist/index.js","require":"./dist/index.js"}},"gitHead":"fce15cbf632d224df365756c989cf5dd26c17976","scripts":{"build":"tsc -p tsconfig.build.json","clean":"clean","commit":"commit","source":"generate-source output=documentation.md exclude=dist/,node_modules/,.git/","patch:undo":"find . -type f -name \"*.ts\" -delete && find . -type f -name \"*.ts.orig\" -exec sh -c 'mv \"$0\" \"$(dirname \"$0\")/$(basename \"$0\" .orig)\"' \\;","split-code":"split-code source=combined.ts markers=src/,lib/ outputDir=./output","patch:apply":"patch -p2 -F3 -b < patch.diff","publish-npm":"publish-npm patch","patch:del-ori":"find . -type f -name \"*.ts.orig\" -delete"},"_npmUser":{"name":"alvamind","email":"alvaminddigital@gmail.com"},"repository":{"url":"git+https://github.com/alvamind/alvamind-ts.git","type":"git"},"_npmVersion":"9.2.0","description":"A lightweight state management library","directories":{},"_nodeVersion":"20.16.0","dependencies":{"alvamind-tools":"^1.0.23"},"_hasShrinkwrap":false,"devDependencies":{"tinybench":"^3.1.1","@types/bun":"latest","typescript":"^5.7.3"},"peerDependencies":{"typescript":"^5.0.0"},"_npmOperationalInternal":{"tmp":"tmp/alvamind_1.0.12_1739832677013_0.6146087187288944","host":"s3://npm-registry-packages-npm-production"}},"1.0.13":{"name":"alvamind","version":"1.0.13","description":"A lightweight state management library","keywords":["state-management","typescript"],"type":"module","author":"","license":"MIT","main":"./dist/index.js","module":"./dist/index.js","types":"./dist/index.d.ts","repository":{"type":"git","url":"git+https://github.com/alvamind/alvamind-ts.git"},"exports":{".":{"require":"./dist/index.js","import":"./dist/index.js","types":"./dist/index.d.ts"}},"devDependencies":{"@types/bun":"latest","tinybench":"^3.1.1","typescript":"^5.7.3"},"peerDependencies":{"typescript":"^5.0.0"},"dependencies":{"alvamind-tools":"^1.0.23"},"scripts":{"build":"tsc -p tsconfig.build.json","source":"generate-source output=documentation.md exclude=dist/,node_modules/,.git/","commit":"commit","clean":"clean","split-code":"split-code source=combined.ts markers=src/,lib/ outputDir=./output","publish-npm":"publish-npm patch","patch:apply":"patch -p2 -F3 -b < patch.diff","patch:del-ori":"find . -type f -name \"*.ts.orig\" -delete","patch:undo":"find . -type f -name \"*.ts\" -delete && find . -type f -name \"*.ts.orig\" -exec sh -c 'mv \"$0\" \"$(dirname \"$0\")/$(basename \"$0\" .orig)\"' \\;"},"gitHead":"0f0bb2d2b5487dabfb863b492b04846f7574be46","bugs":{"url":"https://github.com/alvamind/alvamind-ts/issues"},"homepage":"https://github.com/alvamind/alvamind-ts#readme","_id":"alvamind@1.0.13","_nodeVersion":"20.16.0","_npmVersion":"9.2.0","dist":{"integrity":"sha512-0/MKenrbuYGVeKu7Ja0TIZ0Wdjy3MSz4W+8KlMFYwunuBYBjwWyAXKvsODdqhSXQFO2OflIqiBWJZxDkaIcWUg==","shasum":"e26bfc47706c584db3a2869a4df94539118829d4","tarball":"https://registry.npmjs.org/alvamind/-/alvamind-1.0.13.tgz","fileCount":10,"unpackedSize":61909,"signatures":[{"keyid":"SHA256:DhQ8wR5APBvFHLF/+Tc+AYvPOdTpcIDqOhxsBHRwC7U","sig":"MEYCIQDXfOQowMx9TAtudWnva+r68EaGIurgxD5/F3g3GT+n+wIhAKWhpIuynJ8aCgCj6FXRacXam46585QGKEvqdDGyoTa2"}]},"_npmUser":{"name":"alvamind","email":"alvaminddigital@gmail.com"},"directories":{},"maintainers":[{"name":"alvamind","email":"alvaminddigital@gmail.com"}],"_npmOperationalInternal":{"host":"s3://npm-registry-packages-npm-production","tmp":"tmp/alvamind_1.0.13_1739934779692_0.32793446363654644"},"_hasShrinkwrap":false}},"time":{"created":"2025-02-12T04:38:58.181Z","modified":"2025-02-19T03:13:00.001Z","1.0.1":"2025-02-12T04:38:58.411Z","1.0.2":"2025-02-12T04:52:01.562Z","1.0.3":"2025-02-12T05:11:30.142Z","1.0.4":"2025-02-14T09:05:27.016Z","1.0.5":"2025-02-14T09:16:02.738Z","1.0.6":"2025-02-14T16:25:50.377Z","1.0.7":"2025-02-15T07:36:10.082Z","1.0.9":"2025-02-15T10:51:54.333Z","1.0.10":"2025-02-15T13:05:50.651Z","1.0.11":"2025-02-17T12:39:00.052Z","1.0.12":"2025-02-17T22:51:17.225Z","1.0.13":"2025-02-19T03:12:59.851Z"},"bugs":{"url":"https://github.com/alvamind/alvamind-ts/issues"},"license":"MIT","homepage":"https://github.com/alvamind/alvamind-ts#readme","keywords":["state-management","typescript"],"repository":{"type":"git","url":"git+https://github.com/alvamind/alvamind-ts.git"},"description":"A lightweight state management library","maintainers":[{"name":"alvamind","email":"alvaminddigital@gmail.com"}],"readme":"# 🧙‍♂️ Alvamind 🧠: Modular Magic for TypeScript Applications ✨\n\n> **Conjure State, Compose Logic, and Weave Wonders!** ✨\n\n[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)\n[![Tests](https://github.com/your-username/alvamind/actions/workflows/test.yml/badge.svg)](https://github.com/your-username/alvamind/actions/workflows/test.yml)\n[![Codecov](https://codecov.io/gh/your-username/alvamind/branch/main/graph/badge.svg?token=YOUR_CODECOV_TOKEN)](https://codecov.io/gh/your-username/alvamind)\n[![npm version](https://badge.fury.io/js/alvamind.svg)](https://badge.fury.io/js/alvamind)\n\n```\n    █████╗ ██╗    ██╗   ██╗ █████╗ ███╗   ███╗██╗███╗   ██╗██████╗\n   ██╔══██╗██║    ██║   ██║██╔══██╗████╗ ████║██║████╗  ██║██╔══██╗\n   ███████║██║    ██║   ██║███████║██╔████╔██║██║██╔██╗ ██║██║  ██║\n   ██╔══██║██║    ╚██╗ ██╔╝██╔══██║██║╚██╔╝██║██║██║╚██╗██║██║  ██║\n   ██║  ██║███████╗╚████╔╝ ██║  ██║██║ ╚═╝ ██║██║██║ ╚████║██████╔╝\n   ╚═╝  ╚═╝╚══════╝ ╚═══╝  ╚═╝  ╚═╝╚═╝     ╚═╝╚═╝╚═╝  ╚═══╝╚═════╝\n```\n\nAlvamind is a **lightweight and powerful TypeScript library** for building robust, maintainable, and testable applications using functional programming. It empowers you with dependency injection, immutable state management, functional composition, and lifecycle hooks, all while promoting a \"composition over inheritance\" philosophy.  It focuses on your *application logic*, leaving the HTTP/transport layer to your preferred tools. Think of it as a way to structure your *business logic* – the core rules, data transformations, and service interactions – with the clarity and predictability of pure functions, *without* the complexities of classes or decorators.\n\nIt's **framework-agnostic**, designed to work with *any* server library (Express, Fastify, Elysia, etc.) or even in non-server contexts (CLI tools, background jobs).\n\n## Table of Contents\n\n- [Core Features](#core-features)\n- [Why Alvamind? (OOP vs. Composition)](#why-alvamind-oop-vs-composition)\n- [Design Philosophy: My Vision for Alvamind 🧠](#design-philosophy-my-vision-for-alvamind-)\n- [Installation](#installation)\n- [Getting Started 🚀](#getting-started-)\n- [The Basics: A Simple Counter](#the-basics-a-simple-counter)\n- [Dependency Injection: Summoning Helpers](#dependency-injection-summoning-helpers)\n- [State Management: The Orb of Observation](#state-management-the-orb-of-observation)\n- [Composition with `pipe`: Chaining Spells](#composition-with-pipe-chaining-spells)\n- [Lifecycle Hooks: Rituals of Start and Stop](#lifecycle-hooks-rituals-of-start-and-stop)\n- [Lazy Modules: Delayed Incantations](#lazy-modules-delayed-incantations)\n- [Error Handling: When Spells Go Wrong](#error-handling-when-spells-go-wrong)\n- [Advanced Usage: The Archmage's Secrets](#advanced-usage-the-archmages-secrets)\n  - [Chaining Derivations](#chaining-derivations)\n  - [Decorating the Instance](#decorating-the-instance)\n  - [Combining Multiple Modules](#combining-multiple-modules)\n- [API Reference](#api-reference)\n  -  [`Alvamind`](#alvamind)\n  -  [`use`](#use)\n  -  [`derive`](#derive)\n  -  [`decorate`](#decorate)\n  -  [`watch`](#watch)\n  -  [`onStart`](#onstart)\n  -  [`onStop`](#onstop)\n  -  [`pipe`](#pipe)\n  -  [`lazy`](#lazy)\n- [Examples](#examples)\n- [Roadmap](#roadmap)\n- [Contributing](#contributing)\n- [License](#license)\n\n## Core Features\n\n*   **Modular Design:** Break your app into independent, reusable modules like Lego bricks.\n*   **Dependency Injection:** No more tangled wires! Inject dependencies with the `.use()` method.\n*   **Immutable State:**  Keep your state pristine. Mutations happen immutably via `.set()`.\n*   **Reactive State:** Watch for changes with `.watch()` and react accordingly.  🔮\n*   **Functional Composition:** Use `.pipe()` to create elegant data flows.\n*   **Lifecycle Hooks:** `.onStart()` and `.onStop()` for setup and teardown.\n*   **Lazy Loading:** Handle circular dependencies with `lazy()`.  It's like magic, but it's just clever code. 😉\n*   **Testable by Design:**  Each module is an isolated unit, making testing a breeze.\n*   **TypeScript First:**  Enjoy strong typing and excellent IDE support.\n*   **Side Effect Management:** Integrate seamlessly with tools like `fp-ts` to control side effects.\n*   **Minimal Footprint:** Small, lightweight library with no unnecessary dependencies.\n\n## Why Alvamind? (OOP vs. Composition)\n\nTraditional Object-Oriented Programming (OOP) relies heavily on inheritance to share behavior between classes. While inheritance can be useful, it often leads to:\n\n*   **Tight Coupling:** Classes become heavily reliant on their parent classes.\n*   **The Fragile Base Class Problem:** Changes in a base class can have unintended consequences in derived classes.\n*   **The Diamond Problem:** Multiple inheritance can lead to complex and ambiguous relationships.\n*   **Rigidity:**  Adding new functionality often requires modifying existing class hierarchies.\n\nAlvamind embraces *composition over inheritance*. Instead of creating deep class hierarchies, you build modules from smaller, reusable units of functionality.  This approach offers:\n\n*   **Loose Coupling:** Modules are independent and can be changed without affecting other modules.\n*   **Flexibility:**  You can easily combine modules in different ways to create new functionality.\n*   **Testability:**  Each module is an isolated unit, making testing simpler.\n*   **Reusability:**  Modules can be reused in different parts of your application.\n\nAlvamind allows you to achieve complex functionality similar to OOP inheritance, but with more flexibility and maintainability.  It lets you model your application in terms of *capabilities* rather than strict classifications.\n\n**OOP Example (Problematic):**\n\n```typescript\nclass Animal {\n  makeSound() { console.log(\"Generic animal sound\"); }\n}\n\nclass Dog extends Animal {\n  makeSound() { console.log(\"Woof!\"); }\n  fetch() { console.log(\"Fetching!\"); }\n}\n\nclass Cat extends Animal {\n  makeSound() { console.log(\"Meow!\"); }\n  climb() { console.log(\"Climbing!\"); }\n}\n\n// What if we need a ClimbingDog?  More subclasses?  Inheritance gets messy!\n```\n\n**Alvamind (Composition) Example:**\n\n```typescript\nimport { Alvamind } from 'alvamind';\n\nconst soundModule = Alvamind({ name: 'SoundModule' }).decorate('makeSound', (sound: string) => console.log(sound));\nconst climbModule = Alvamind({ name: 'ClimbModule' }).decorate('climb', () => console.log(\"Climbing!\"));\n\nconst dogModule = Alvamind({ name: 'DogModule' })\n  .use(soundModule)\n  .derive(({ makeSound }) => ({\n    bark() { makeSound(\"Woof!\"); },\n    fetch() { console.log(\"Fetching!\"); }\n  }));\n\nconst catModule = Alvamind({ name: 'CatModule' })\n  .use(soundModule)\n  .use(climbModule) // Cats also climb!\n  .derive(({ makeSound, climb }) => ({\n    meow() { makeSound(\"Meow!\"); },\n    climb\n  }));\n\n//Creating a climbing dog is trivial!!\nconst climbingDogModule = Alvamind({name: 'ClimbingDog'}).use(dogModule).use(climbModule)\nclimbingDogModule.climb() // climbing\n\n```\n\n## Design Philosophy: My Vision for Alvamind 🧠\n\nI created Alvamind because I'm passionate about the modularity of NestJS and the speed and simplicity of ElysiaJS (and Bun!). I'm also a firm believer in functional programming (FP) for building robust, testable, and maintainable code. My question was:\n\n**\"Can we combine the best of both worlds?  NestJS's structure *without* classes and decorators, and ElysiaJS's functional elegance and performance?\"**\n\nAlvamind is my answer. It distills the *essence* of NestJS's modularity, separation of concerns, and dependency injection, reimagining them through a purely functional lens, optimized for speed and developer experience. I wanted the expressiveness of Elysia's chaining, but with the architectural power of Nest.\n\nIt's not just *another* way to write functions. It *guides* developers towards well-structured applications, encouraging good practices through its design. Type safety is a *given*, not an afterthought. And it's *fast*.\n\n### Functional Programming Principles – The Foundation\n\nAlvamind is built on the core tenets of functional programming. This isn't just a style choice; it's about how software should be built.\n\n#### Pure Functions: The Building Blocks 🧱\n\nPure functions are predictable: same input, same output, *no side effects*. This makes them easy to test, reason about, and compose. Alvamind encourages you to write your core logic as pure functions.\n\n```typescript\n// Pure function\nconst add = (a: number, b: number): number => a + b;\n\n// Impure function (side effect: modifies 'total')\nlet total = 0;\nconst addToTotal = (a: number): void => { total += a; };\n```\n\nAlvamind *loves* pure functions. They're the bedrock.\n\n#### Immutability: No Surprises 🛡️\n\nMutable state is a bug magnet. When data changes unexpectedly, it's hard to track down errors. Alvamind promotes immutability: treat data as read-only. Instead of modifying objects, create *new* ones.\n\n```typescript\n// Mutable (BAD)\nconst user = { name: 'Alice', age: 30 };\nuser.age = 31; // Modifies the original\n\n// Immutable (GOOD)\nconst user = { name: 'Alice', age: 30 };\nconst updatedUser = { ...user, age: 31 }; // Creates a new object\n```\n\nAlvamind's state management (`.state()`) is built on immutability.\n\n#### Composition over Inheritance: Flexibility and Control 🧩\n\nClassical inheritance (`extends`) can create rigid hierarchies. Functional composition is like LEGO bricks: combine small, independent functions to create larger behaviors. It's more flexible and maintainable.\n\n```typescript\n// Inheritance (Rigid)\nclass Animal {\n  move() { /* ... */ }\n}\nclass Dog extends Animal {\n  bark() { /* ... */ }\n}\n\n// Composition (Flexible)\nconst canMove = () => ({\n  move: () => { /* ... */ }\n});\nconst canBark = () => ({\n  bark: () => { /* ... */ }\n});\n\nconst dog = { ...canMove(), ...canBark() };\n```\n\nAlvamind's `.use()`, `.derive()`, and `.pipe()` are all about composition.\n\n#### Explicit Dependencies: Clarity and Testability 💉\n\nHidden dependencies make code hard to understand and test. Alvamind *forces* you to be explicit. Modules declare their needs, and those needs are provided through injection. This makes it clear what a module relies on, and easy to swap dependencies for testing (e.g., using mocks).\n\n```typescript\n// Implicit Dependency (BAD)\nconst createUser = async (data) => {\n  await db.users.create(data); // `db` is a global, hidden dependency\n};\n\n// Explicit Dependency (GOOD)\nconst createUser = ({ db }) => async (data) => {\n  await db.users.create(data); // `db` is explicitly provided\n};\n```\n\nAlvamind's `.use()` and `.derive()` mechanisms enforce explicit dependency injection.\n\n#### Controlled Side Effects: Predictability and Reliability ⚙️\n\nSide effects (API calls, database writes, logging) are unavoidable. But *uncontrolled* side effects are a major source of bugs. Alvamind helps you manage them predictably, using techniques inspired by `fp-ts`. This often involves wrapping side effects in structures like `Task` or `Either` (provided through Alvamind's context), representing asynchronous operations or computations that can fail.\n\n```typescript\n// Uncontrolled Side Effect (BAD)\nconst saveUser = async (user) => {\n  await db.save(user);      // Directly interacts with the database\n  sendWelcomeEmail(user.email); // Another side effect\n};\n\n// Controlled Side Effect (GOOD) - using Alvamind's context for fp-ts\nconst userModule = Alvamind({ name: 'UserModule' })\n.derive(({ db, emailService, TE }) => ({ // Inject and access TE (TaskEither)\n  saveUser: (user) =>\n    pipe(\n      TE.tryCatch(() => db.save(user), toError), // Wrap in TaskEither\n      TE.chain((savedUser) =>\n        TE.tryCatch(() => emailService.sendWelcome(savedUser.email), toError)\n      )\n    )\n}));\n```\nAlvamind context make it easier to access `fp-ts` function.\n\n### Type-First Development: Confidence and Correctness\n\nI'm a TypeScript enthusiast. Strong typing is *essential* for robust applications. But I also dislike unnecessary verbosity. Alvamind maximizes type inference, so you get type safety with minimal manual annotations.\n\n#### Strong Type Inference: Let TypeScript Work for You 🦾\n\nAlvamind leverages TypeScript's inference to automatically determine types. This reduces boilerplate and makes code concise, while still catching errors at compile time.\n\n```typescript\n// Alvamind infers types automatically\nconst userModule = Alvamind({ name: 'UserModule' })\n  .derive(() => ({\n    // TypeScript knows `createUser` takes a string and returns a Promise<string>\n    createUser: (name: string) => Promise.resolve(`User ${name} created`)\n  }));\n\nconst result = await userModule.createUser('Alice'); // TypeScript knows `result` is a string\n```\n\n#### Type Safety without Verbosity: The Best of Both Worlds\n\nAlvamind provides strong type safety *without* requiring tons of annotations. It infers types whenever possible, but provides mechanisms (like generic type parameters) for explicit constraints when needed.\n\n```typescript\n// Explicit type constraints when needed\ninterface User {\n  id: string;\n  name: string;\n}\n\nconst userModule = Alvamind<User>({ name: 'UserModule' }); // Enforce User type\n```\n\n### Railway-Oriented Programming: Elegant Error Handling 🛤️\n\nError handling is often messy, with `try-catch` blocks scattered everywhere. Alvamind embraces Railway-Oriented Programming (ROP): errors are a separate \"track.\" This leads to cleaner code and consistent error management.\n\n```typescript\n\n// Traditional Error Handling (Messy)\nconst processOrder = (order) => {\n    try {\n      const validated = validateOrder(order);\n      try {\n        const processed = processPayment(validated);\n        return { success: true, order: processed };\n      } catch (paymentError) {\n        return { success: false, error: paymentError };\n      }\n    } catch (validationError) {\n      return { success: false, error: validationError };\n    }\n  };\n\n// Railway-Oriented Programming (Clean) - using Alvamind's context for fp-ts\nconst orderModule = Alvamind({ name: 'OrderModule' })\n.derive(({E})=>({\n    processOrder: (order) =>\n    pipe(\n      validateOrder(order), // Returns Either\n      E.chain(processPayment),  // Only called on success\n      E.fold( // Handle both success and failure\n        (error) => ({ status: 'error', error: error.message }),\n        (result) => ({ status: 'success', order: result })\n      )\n    )\n}));\n```\n\nAlvamind's `.pipe()` and `E.chain` methods (from `fp-ts`), facilitate ROP.\n\n### Anti-Patterns: What Alvamind *Discourages*\n\nTo achieve its goals, Alvamind discourages:\n\n*   **Mutable State:** Immutability is core.\n*   **Hidden Dependencies:** All dependencies should be explicit.\n*   **Classical Inheritance:** Favor composition.\n*   **Type Assertions (`as any`, `as unknown`):** Rely on inference and proper definitions.\n*   **Uncontrolled Side Effects:** Manage them using controlled mechanisms.\n*   **Global Scope:** Avoid global variables. Modules should be self-contained.\n\nBy avoiding these, Alvamind helps you write predictable, testable, and maintainable code.\n\nIn essence, Alvamind is my love letter to functional programming, TypeScript, and well-structured applications. It's built on strong principles, to help you build amazing software with confidence. It's the framework I *wish* I had, and I hope it helps you too!\n\n## Installation\n\n```bash\nbun install alvamind # or npm install alvamind / yarn add alvamind\n```\n\n## Getting Started 🚀\n\nLet's create a simple \"Greeter\" module:\n\n```typescript\n// src/greeter.module.ts\nimport { Alvamind } from 'alvamind';\n\n// Create a Alvamind module\nexport const greeterModule = Alvamind({\n  name: 'GreeterModule',\n})\n.decorate('greet', (name: string) => `Hello, ${name}!`)\n.derive(({ greet }) => ({ // Access the `greet` function\n  greetUser: (name: string) => greet(name), // Expose a method\n}));\n\n// src/main.ts\nimport { greeterModule } from './greeter.module';\n\nfunction main() {\n  const greeting = greeterModule.greetUser('World'); // Call the method. Types are inferred!\n  console.log(greeting); // Output: Hello, World!\n}\n\nmain();\n```\n\n**Explanation:**\n\n1.  **`greeter.module.ts`:**\n\n    *   We import the `Alvamind` class.\n    *   We create a module named `GreeterModule`.\n    *   `.decorate('greet', ...)` adds a `greet` function.\n    *   `.derive(({ greet }) => ...)` creates a `greetUser` method, using the `greet` function.  Note the *explicit dependency*.\n2.  **`main.ts`:**\n\n    *   We import the `greeterModule`.\n    *   We call `greetUser`. TypeScript *automatically knows* the argument and return types!\n\n**Running the Example:**\n\n1.  Create `src/greeter.module.ts` and `src/main.ts`.\n2.  Initialize a TypeScript project (if needed):\n\n    ```bash\n    npm init -y\n    tsc --init # Creates tsconfig.json\n    ```\n3.  Make sure you have installed `alvamind`.\n4.  Compile and run:\n\n    ```bash\n    tsc\n    node src/main.js\n    ```\n\n    You should see \"Hello, World!\" printed.\n\nLet's expand this with more features, including state and simple, built-in validation.\n\n```typescript\n// src/user.module.ts\nimport { Alvamind } from 'alvamind';\n\ninterface UserState {\n  users: string[];\n}\n\nexport const userModule = Alvamind<UserState>({\n  name: 'UserModule',\n  state: { users: [] }, // Initial state: an array of strings\n})\n.decorate('isValidUser', (user: unknown) => typeof user === 'string') // Simple validation\n.derive(({ isValidUser, state }) => ({ // Access state and isValidUser\n    createUser: (userData: string) => {\n        if (!isValidUser(userData)) { // Use the validation function\n            throw new Error(\"Invalid user data\");\n        }\n\n        const current = state.get();\n        state.set({ users: [...current.users, userData] }); // Immutable state update\n        return userData;\n    },\n    getUsers: () => state.get().users,\n}))\n.onStart(() => { // onStart lifecycle hook\n    console.log(\"User module Started\");\n});\n\n// src/main.ts\nimport { userModule } from './user.module';\n\nfunction main() {\n    const createdUser = userModule.createUser('Alice'); // Type-safe!\n    console.log(createdUser);\n    console.log(userModule.getUsers());\n    //  userModule.createUser(123); // Throws an error: \"Invalid user data\"\n}\n\nmain();\n```\n\nKey takeaways:\n\n*   **`state`:**  We initialize the module with an empty array of strings as its state.\n*   **`isValidUser`:**  A simple validation function (using `.decorate`).\n*   **`.derive()`:**\n\n    *   `createUser`:  Validates the input *before* adding it to the state.\n    *   `getUsers`:  Retrieves the current list of users.\n    *   **Immutability:** We use the spread operator (`...`) to create a *new* array when updating the state, ensuring immutability.\n*   **`.onStart()`:** A lifecycle hook that runs when the module is initialized.\n*   **Type Safety:**  Even without explicit type annotations in many places, TypeScript and Alvamind infer the types correctly.\n\n## The Basics: A Simple Counter\n\nLet's create a counter module.  No wands required!\n\n```typescript\nimport { Alvamind } from 'alvamind';\n\ninterface CounterState {\n  count: number;\n}\n\nconst counterModule = Alvamind<CounterState>({\n  name: 'CounterModule',\n  state: { count: 0 },\n})\n.derive(({ state }) => ({\n  increment: () => state.set({ count: state.get().count + 1 }),\n  decrement: () => state.set({ count: state.get().count - 1 }),\n  getCount: () => state.get().count,\n}));\n\n// Use it!\ncounterModule.increment();\nconsole.log(counterModule.getCount());\ncounterModule.decrement();\nconsole.log(counterModule.getCount());\n```\n\n## Dependency Injection: Summoning Helpers\n\nNeed a logger?  Inject it!\n\n```typescript\nimport { Alvamind } from 'alvamind';\n\nconst logger = {\n  log: (message: string) => console.log(`[LOG]: ${message}`),\n};\n\nconst userModule = Alvamind({ name: 'UserModule' })\n  .use(logger) // Inject the logger!\n  .derive(({ log }) => ({\n    createUser: (name: string) => {\n      log(`Creating user: ${name}`); // Use the injected logger\n      return { id: 1, name };\n    },\n  }));\n\nconst user = userModule.createUser('Gandalf');\n```\n\n## State Management: The Orb of Observation\n\nWatch for changes in your state.\n\n```typescript\nimport { Alvamind } from 'alvamind';\n\ninterface InventoryState {\n  gold: number;\n}\n\nconst inventoryModule = Alvamind<InventoryState>({\n  name: 'InventoryModule',\n  state: { gold: 100 },\n})\n  .watch('gold', (newGold, oldGold) => {\n    console.log(`Gold changed from ${oldGold} to ${newGold}`);\n  })\n  .derive(({ state }) => ({\n    addGold: (amount: number) =>\n      state.set({ gold: state.get().gold + amount }),\n    getGold: () => state.get().gold,\n  }));\n\ninventoryModule.addGold(50);\n```\n\n## Composition with `pipe`: Chaining Spells\n\nCreate data pipelines like a pro using the power of `fp-ts`.\n\n```typescript\nimport { Alvamind, type Either } from 'alvamind';\nimport * as E from 'fp-ts/Either'\n\nconst mathModule = Alvamind({ name: 'MathModule' })\n  .derive(() => ({\n    double: (n: number) => n * 2,\n    addOne: (n: number) => n + 1,\n    checkPositive: (n:number):Either<string, number> => n > 0 ? E.right(n) : E.left('Number must be positive'),\n  }))\n  .pipe('process', ({ double, addOne, pipe, checkPositive }) =>\n     (input: number) => pipe(\n        input,\n        checkPositive,\n        E.map(double),\n        E.map(addOne),\n        E.getOrElse((e:string) => e)\n    )\n  );\n\nconsole.log(mathModule.process(5)); // Outputs: 11\nconsole.log(mathModule.process(-2)); // Outputs: \"Number must be positive\"\n```\n\n## Lifecycle Hooks: Rituals of Start and Stop\n\nPerform actions when your module starts or stops.\n\n```typescript\nimport { Alvamind } from 'alvamind';\n\nconst connectionModule = Alvamind({ name: 'ConnectionModule' })\n  .onStart(({ config }) => {\n    console.log('Connecting to database...');\n    // Imagine some connection logic here...\n  })\n  .onStop(() => {\n    console.log('Closing database connection...');\n    // Imagine some disconnection logic here...\n  })\n  .derive(() => ({\n      connect: () => {\n        console.log('connecting')\n      },\n      close: () => module.stop() // Stop the module\n\n  }));\n\nconnectionModule.connect();\nconnectionModule.close()\n// Connecting to database...\n// Closing database connection...\n\n```\n\n## Lazy Modules: Delayed Incantations\n\nHandle those pesky circular dependencies.\n\n```typescript\nimport { Alvamind, lazy } from 'alvamind';\n\nconst moduleB = Alvamind({ name: 'ModuleB' })\n  .derive(({doA}) => ({\n    doB: (input: string) =>  doA ? doA(input + ' -> B') : 'B' ,\n  }));\n\nconst moduleA = Alvamind({ name: 'ModuleA' })\n// .use(moduleB) // ⚠️ This would cause a circular dependency!\n  .derive(() => ({\n    doA: (input: string) => moduleB.doB(input + ' -> A'),\n  }));\n\nconst mainModule = Alvamind({name: 'MainModule'})\n    .use(moduleA)\n    .use(lazy(moduleB))\n    .derive(({doA}) => ({\n        start: () => doA('Start')\n    }))\nconsole.log(mainModule.start()); // Output: Start -> A -> B -> A -> B ...\n\n```\n\n## Error Handling: When Spells Go Wrong\n\nAlvamind integrates well with `fp-ts`, using its `Either` you can manage errors properly.\n\n```typescript\nimport { Alvamind } from 'alvamind';\n\nconst module = Alvamind({ name: \"ErrorModule\" })\n  .pipe(\"dangerousOperation\", () => (input: unknown) => {\n    if (typeof input !== \"string\") {\n      return \"ERROR\";\n    }\n    return (input as string).toUpperCase();\n  });\n\nconsole.log(module.dangerousOperation(\"test\")); // \"TEST\"\nconsole.log(module.dangerousOperation(123));   // \"ERROR\"\n\n```\n\n## Advanced Usage: The Archmage's Secrets\n\n### Chaining Derivations\n\nYou can chain `.derive()` calls to build up complex APIs:\n\n```typescript\nimport { Alvamind } from 'alvamind';\n\nconst complexModule = Alvamind({ name: 'ComplexModule', state: {value: 1} })\n  .derive(({state}) => ({\n    setValue: (val: number) => state.set({ value: val }),\n  }))\n  .derive(({state}) => ({\n    doubleValue: () => state.set({value: state.get().value * 2}),\n  }))\n    .derive(({setValue}) => ({\n        resetValue: () => setValue(1) // Call the derived api, also inside other derive.\n    }))\n\ncomplexModule.doubleValue()\nconsole.log(complexModule.resetValue()) // Returns: 2\n\n```\n\n### Decorating the Instance\n\nAdd custom properties to your module:\n\n```typescript\nimport { Alvamind } from 'alvamind';\n\nconst versionedModule = Alvamind({ name: 'VersionedModule' })\n  .decorate('version', '1.0.0')\n  .derive(() => ({\n     getVersion: () => versionedModule.version\n  }));\n\nconsole.log(versionedModule.version);\nconsole.log(versionedModule.getVersion())\n\n```\n\n### Combining Multiple Modules\n\nShow how to combine multiple feature modules to create complex applications.\n\n```typescript\nimport { Alvamind } from 'alvamind';\n\ninterface CartItem {\n  id: number;\n  name: string;\n  price: number;\n}\n\ninterface CartState {\n  items: CartItem[];\n}\n\n// -- Modules --\n\nconst cartModule = Alvamind<CartState>({\n  name: \"CartModule\",\n  state: { items: [] },\n})\n  .derive(({ state }) => ({\n    addItem: (item: CartItem) => {\n      const currentItems = state.get().items;\n      state.set({ items: [...currentItems, item] });\n    },\n    getCartTotal: () => {\n      const items = state.get().items;\n      return items.reduce((total, item) => total + item.price, 0);\n    },\n    clearCart: () => state.set({ items: [] }),\n  }));\n\nconst discountModule = Alvamind({ name: \"DiscountModule\" })\n  .derive(() => ({\n    applyDiscount: (total: number, discountPercentage: number) => {\n      return total * (1 - discountPercentage / 100);\n    },\n  }));\n\n// -- App Module --\n\nconst appModule = Alvamind({ name: \"AppModule\" })\n  .use(cartModule)\n  .use(discountModule)\n  .derive(({ addItem, getCartTotal, applyDiscount, clearCart }) => ({\n    purchase: (items: CartItem[], discount: number) => {\n      items.forEach(addItem);\n      const total = getCartTotal();\n      const discountedTotal = applyDiscount(total, discount);\n      clearCart(); // Clear after purchase\n      return discountedTotal;\n    },\n  }));\n\n// -- Usage --\n\nconst items = [\n  { id: 1, name: \"Potion\", price: 10 },\n  { id: 2, name: \"Sword\", price: 50 },\n];\nconst discountedPrice = appModule.purchase(items, 10); // 10% discount\nconsole.log(`Final Price: ${discountedPrice}`); // Final Price: 54\n```\n\n## API Reference\n\n### `Alvamind`\n\nCreates an Alvamind module builder.\n\n**Type Signature**:\n`function Alvamind<TState, TConfig>(options: AlvamindOptions<TState, TConfig>): BuilderInstance`\n\n**Parameters**:\n\n*   `options`:\n\n    *   `name` (*required*): The name of the module (must be unique).\n    *   `state?`: Initial state for the module.\n    *   `config?`: Configuration object for the module.\n\n### `use`\n\nInjects dependencies into the module.\n\n`function use<T extends DependencyRecord | LazyModule<any>>(dep: T): BuilderInstance<TState, TConfig, TDeps & (T extends LazyModule<infer U> ? U : T), TApi>;`\n\n### `derive`\n\nDerives new properties from the context and adds them to the module's API.\n\n`function derive<T extends DependencyRecord>(fn: (ctx: AlvamindContext<TState, TConfig> & TDeps & TApi) => T): BuilderInstance<TState, TConfig, TDeps, TApi & T> & T;`\n\n### `decorate`\n\nAdds custom properties directly to the builder instance and its API.\n\n`function decorate<K extends string, V>(key: K, value: V): BuilderInstance<TState, TConfig, TDeps, TApi & Record<K, V>> & Record<K, V>;`\n\n### `watch`\n\nRegisters a watcher for state changes.\n\n`function watch<K extends keyof TState>(key: K, handler: (newVal: TState[K], oldVal: TState[K]) => void): BuilderInstance<TState, TConfig, TDeps, TApi>;`\n\n### `onStart`\n\nRegisters a hook to be called when the module is initialized.\n\n`function onStart(hook: (ctx: AlvamindContext<TState, TConfig> & TDeps & TApi) => void): BuilderInstance<TState, TConfig, TDeps, TApi>;`\n\n### `onStop`\n\nRegisters a hook to be called when `stop()` is called.\n\n`function onStop(hook: (ctx: AlvamindContext<TState, TConfig> & TDeps & TApi) => void): BuilderInstance<TState, TConfig, TDeps, TApi>;`\n\n### `pipe`\n\nCompose functions fp-ts style.\n\n`function pipe<K extends string, V>(key: K, fn: (ctx: AlvamindContext<TState, TConfig> & TDeps & TApi) => V): BuilderInstance<TState, TConfig, TDeps, TApi & Record<K, V>> & Record<K, V>;`\n\n### `lazy`\n\nUsed for lazy initialization, helps with circular dependencies.\n\n`function lazy<T extends Record<string, unknown>>(module: T): LazyModule<T>;`\n\n## Examples\n\nExplore the `examples/` directory (coming soon!) for more in-depth examples of using Alvamind in different scenarios, including:\n\n*   Simple React integration.\n*   Complex application with multiple modules.\n*   Integrating with external APIs.\n*   Testing strategies.\n\n## Roadmap\n\n*   [ ] More comprehensive documentation and examples.\n*   [ ] Enhanced testing utilities.\n*   [ ] React integration helpers.\n*   [ ] CLI tool for generating Alvamind modules.\n*   [ ] Explore alternative state management approaches (e.g., Immer.js).\n*   [ ] Plugin system.\n*   [ ] Support for other frameworks (Vue, Angular).\n\n## Contributing\n\nContributions are welcome! Fork the repo, create a branch, and send a pull request. Please follow the existing code style and include tests for any new functionality.\n\n## License\n\nMIT.\n\n## Frequently Asked Questions (FAQ)\n\nThis section addresses some critical questions about Alvamind and its design choices.\n\n**Q1: Redundancy with Existing Tools:** We have `fp-ts`, `rxjs`, Redux, Zustand, etc. Why Alvamind?\n\n**A1:** Alvamind isn't meant to *replace* these tools, but to provide a *structured, opinionated way to combine them*. It's a micro-framework, not a full-fledged state management solution or FP library.  It offers:\n\n*   **Unified Structure:**  Alvamind provides a consistent module system that encourages a specific organizational pattern. This can be *more* beneficial than just using individual libraries, especially in larger projects.\n*   **Simplified Dependency Injection:** Alvamind's `use` and `derive` handle dependency injection in a functional way, making it more explicit and less verbose than manually passing dependencies.\n*   **Integrated State Management (Optional):** The built-in state management, while simple, is *integrated* with the module system and immutability. You're *not forced* to use it; you can easily plug in Zustand, Jotai, or others.\n*   **`fp-ts` Bridge:** Alvamind provides convenient access to `fp-ts` functions within its context, reducing boilerplate for common patterns.\n\nAlvamind's value lies in its *combination* of features, providing a \"batteries-included-but-removable\" approach to structuring functional TypeScript applications. It's a *higher-level* abstraction that aims for developer productivity and maintainability.\n\n**Q2: \"Composition over Inheritance\" Silver Bullet?** Isn't composition also complex?\n\n**A2:** You're right, composition *can* be complex. Alvamind mitigates this by:\n\n*   **Explicit Dependencies:**  `use` and `derive` make dependencies very clear, reducing the cognitive load of tracing data flow.\n*   **Module Boundaries:**  Modules provide natural boundaries, limiting the scope of any single composition.  This helps prevent overly complex, deeply nested functions.\n*   **Targeted Scope Control:** The `as: 'scoped'` option prevents accidental leakage of internal implementation details, further simplifying the composition within a module.\n*   **Encouraging Small, Focused Functions:** The overall design pushes developers toward writing many small, well-defined functions, which are easier to compose than large, monolithic ones.\n\nAlvamind *doesn't* claim to eliminate *all* complexity.  Complex problems require *some* complexity in their solutions.  But it aims to make that complexity *manageable* and *explicit*.\n\n**Q3: Hidden Complexity:**  Isn't Alvamind's simplicity just hiding internal complexity?\n\n**A3:** There's *some* internal complexity, but it's relatively small and well-documented. The core concepts (proxies for lazy evaluation, maps for dependency storage) are standard JavaScript techniques. We strive for:\n\n*   **Informative Error Messages:** Alvamind aims to provide helpful error messages that point to the source of the problem within your code, *not* just within the library's internals.\n*   **Clear Stack Traces:** While chained calls can create deeper stack traces, the structure (module names, function names) should generally be clear. We're actively working on improving stack trace clarity.\n*   **Open Source:** The code is open and relatively small. You can inspect it directly to understand the inner workings.\n\nWe're committed to making debugging as straightforward as possible.\n\n**Q4: Performance Overhead:**  What's the actual performance impact?\n\n**A4:** We haven't yet conducted extensive, large-scale benchmarks. However:\n\n*   **Minimal Abstraction:**  The core operations (dependency injection, state updates) are relatively lightweight.\n*   **Pure Function Focus:**  The emphasis on pure functions *allows* for optimizations (like memoization) that you can apply *within* your modules.\n*   **Immutability Benefits:** Immutability, while adding some overhead, can *improve* performance in UI frameworks like React (by enabling efficient change detection).\n\nWe'll be publishing detailed benchmark results as the library matures. We expect the overhead to be negligible in most common scenarios, and we're committed to optimizing performance.\n\n**Q5: Over-Engineering for Simple Cases:** Is Alvamind overkill for small projects?\n\n**A5:** Yes, for *very* small projects (a single file, a few functions), Alvamind might be overkill. Its benefits become more apparent as complexity grows. The \"tipping point\" is subjective, but consider Alvamind when:\n\n*   You have multiple interacting components or services.\n*   You want clear separation of concerns.\n*   You need robust dependency injection.\n*   You anticipate future growth and want to maintain a structured codebase.\n*   You want the benefits of functional programming principles (immutability, pure functions) enforced by the library's structure.\n\nYou can start small and add Alvamind modules as needed.\n\n**Q6: Framework Agnostic, but at What Cost?** Does agnosticism lead to *more* integration code?\n\n**A6:** There's a trade-off. Agnosticism offers flexibility, but it *does* mean you'll need to write some integration code for your specific framework. For example, with React, you might create a custom hook to connect Alvamind modules to component state.\n\nHowever:\n\n*   **Integration is Usually Simple:** This integration is typically straightforward, often just a few lines of code.\n*   **Future-Proofing:** Agnosticism makes your core logic less dependent on a specific framework, making it easier to migrate or adapt to new technologies.\n*   **Reusable Logic:**  Your Alvamind modules can be used *outside* of your UI (e.g., in server-side code, CLI tools, etc.).\n*   **Community Contributions:** We expect the community to develop and share integration helpers for common frameworks.\n\n**Q7: `fp-ts` Integration: Optional or Essential?** Is Alvamind useful *without* `fp-ts`?\n\n**A7:** `fp-ts` is *not* strictly required, but it *significantly enhances* Alvamind's power. You *can* use Alvamind without `fp-ts`:\n\n*   **Basic Functionality:**  Modules, dependency injection, state management, and lifecycle hooks all work without `fp-ts`.\n*   **Custom Error Handling:**  You can use standard `try-catch` or other error handling approaches.\n\nHowever, `fp-ts` provides:\n\n*   **Elegant Error Handling (Either):**  The Railway-Oriented Programming style becomes much easier.\n*   **Powerful Composition (pipe, chain):** `fp-ts` unlocks more advanced functional composition techniques.\n*   **Controlled Side Effects (Task, TaskEither):**  `fp-ts` helps manage asynchronous operations predictably.\n\nWe strongly recommend learning and using `fp-ts` with Alvamind, but it's not a hard requirement.\n\n**Q8: The \"Magic\" Problem:** Does the playful terminology make Alvamind harder to understand?\n\n**A8:** The terminology (\"conjure,\" \"spells\") is intended to be engaging, but we understand the concern about \"magic.\" We strive for:\n\n*   **Clear Documentation:**  The documentation explains the *actual* mechanisms behind the \"magic.\"\n*   **Conceptual Clarity:**  The core concepts (modules, dependencies, state) are standard software engineering principles.\n*   **Open Source:**  The code is available for inspection.\n\nWe'll consider adjusting the terminology if it proves to be a barrier to understanding. The goal is to be approachable, not obfuscating.\n\n**Q9: Community and Ecosystem:** Where's the support for a new library?\n\n**A9:** This is a valid concern. As a new library, Alvamind's community is small but growing. We're addressing this by:\n\n*   **Active Development:** We're actively maintaining and improving the library.\n*   **Responsive Support:** We're responsive to issues and questions on GitHub.\n*   **Comprehensive Documentation:** We're committed to providing clear and thorough documentation.\n*   **Community Building:** We're actively engaging with potential users and contributors.\n*   **Long-Term Commitment:** We're dedicated to the long-term success of Alvamind.\n\nWe encourage you to join the community, ask questions, and contribute!\n\n**Q10: Scalability in *Large* Teams:** How does Alvamind help with *social* scalability?\n\n**A10:** Alvamind provides structural benefits that *aid* large-team scalability, but it's *not* a complete solution for all large-team challenges. It helps by:\n\n*   **Modularity:**  Modules provide natural boundaries for code ownership and reduce conflicts.\n*   **Explicit Dependencies:** `use` and `derive` make it clear which modules depend on others, simplifying impact analysis.\n*   **Testability:**  Easily testable modules reduce the risk of regressions.\n*   **Scope Control** `as:'scoped'` helps prevent access to internal modules.\n\nHowever, Alvamind *doesn't* directly address:\n\n*   **Code Ownership Enforcement:** You'll still need tools like code review and branch protection.\n*   **Access Control (Beyond Scope):** Alvamind doesn't have built-in role-based access control.\n*   **Module Versioning:**  You'll need to manage module versions (e.g., using a monorepo and package management).\n\nAlvamind provides a solid *foundation* for large-team development, but it's not a replacement for good development practices and tooling. It's a *tool*, not a silver bullet.\n","readmeFilename":"README.md"}