@signaltree/core 4.0.7 → 4.0.9

package/LICENSE

@@ -0,0 +1,54 @@
+BUSINESS SOURCE LICENSE 1.1
+
+Copyright (c) 2025 Jonathan D Borgia
+
+This Business Source License 1.1 ("License") governs the use of the software and associated documentation files (the "Software"). You are granted a limited license to use the Software under the terms of this License.
+
+1. Definitions
+
+"Change Date" means the date on which the Change License set out in section 6 will apply to the Software. The Change Date for this release is 2028-09-05.
+
+"Change License" means the open source license that will apply to the Software on and after the Change Date. The Change License for this release is the MIT License.
+
+"Licensor" means the copyright owner granting rights under this License (Jonathan D Borgia).
+
+"You" ("Licensee") means an individual or legal entity exercising rights under this License who has not violated the terms of this License or had their rights terminated.
+
+2. License Grant
+
+Subject to the terms and conditions of this License, Licensor hereby grants You a non-exclusive, non-transferable, worldwide license to use, reproduce, display, perform, and distribute the Software, and to make modifications and derivative works for internal use, until the Change Date.
+
+3. Commercial Use
+
+You may use the Software in commercial applications, including for providing services, selling products that include the Software, or otherwise exploiting the Software commercially, subject to the other terms of this License.
+
+4. Limitations and Conditions
+
+a. You may not remove or alter this License, the copyright notice, or notices of the Change Date.
+
+b. You may not publicly offer a modified version of the Software that would directly compete with Licensor's public offering of the Software if doing so would circumvent the intent of this License.
+
+c. Except as expressly provided in this License, no rights are granted to You under any patent or trademark of Licensor.
+
+5. Disclaimer and Limitation of Liability
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. TO THE FULLEST EXTENT PERMITTED BY LAW, LICENSOR WILL NOT BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY ARISING FROM OR RELATING TO THE SOFTWARE.
+
+6. Change License
+
+On and after the Change Date specified above, the Software will be licensed under the Change License (MIT License) on the same terms and conditions as set forth by that Change License.
+
+7. Governing Law
+
+This License will be governed by and construed in accordance with the laws of the State of New York, USA, without regard to conflict of law principles.
+
+8. Accepting this License
+
+You accept this License by copying, modifying, or distributing the Software or any portion thereof.
+
+---
+
+LICENSE NOTE
+
+- Original license file replaced on 2025-09-05 to Business Source License 1.1. Change Date: 2028-09-05. Change License: MIT.
+  or standard modifications for your own applications.

package/README.md

@@ -254,10 +254,10 @@ effect(() => {
 
 ### Performance optimization with memoization
 
-When combined with `@signaltree/memoization`, computed values become even more powerful:
+Computed values become even more powerful with the built-in memoization enhancer:
 
 ```typescript
-import { withMemoization } from '@signaltree/core';
+import { signalTree, withMemoization } from '@signaltree/core';
 
 const tree = signalTree({
   items: Array.from({ length: 10000 }, (_, i) => ({
@@ -385,7 +385,7 @@ tree.$.config.settings.nested.set(false); // ✅ boolean
 
 ### 3) Manual state management
 
-Core provides basic state updates - entity management requires `@signaltree/entities`:
+Core provides basic state updates. For advanced entity management, use the built-in `withEntities` enhancer:
 
 ```typescript
 interface User {
@@ -419,7 +419,7 @@ const activeUsers = computed(() => tree.$.users().filter((user) => user.active))
 
 ### 4) Manual async state management
 
-Core provides basic state updates - async helpers are now provided via `@signaltree/middleware` helpers:
+Core provides basic state updates. For advanced async helpers, use the built-in middleware functions (`createAsyncOperation`, `trackAsync`):
 
 ```typescript
 const tree = signalTree({
@@ -466,40 +466,57 @@ class UsersComponent {
 
 ### 6) Enhancers and composition
 
-SignalTree Core provides the foundation, but its real power comes from composable enhancers. Each enhancer is a focused, tree-shakeable extension that adds specific functionality.
+SignalTree Core provides a complete set of built-in enhancers. Each enhancer is a focused, tree-shakeable extension that adds specific functionality.
 
-#### Available Enhancers
+#### Available Enhancers (All in @signaltree/core)
+
+All enhancers are exported directly from `@signaltree/core`:
 
 **Performance Enhancers:**
 
-- `@signaltree/batching` - Batch updates to reduce recomputation and rendering
-- `@signaltree/memoization` - Intelligent caching for expensive computations
+- `withBatching()` - Batch updates to reduce recomputation and rendering
+- `withMemoization()` - Intelligent caching for expensive computations
+- `withHighPerformanceBatching()` - Advanced batching for high-frequency updates
+- `withHighPerformanceMemoization()` - Optimized memoization for large state trees
 
 **Data Management:**
 
-- `@signaltree/entities` - Advanced CRUD operations for collections
-- Async helpers are provided via `@signaltree/middleware` (createAsyncOperation / trackAsync)
-- `@signaltree/serialization` - State persistence and SSR support
+- `withEntities()` - Advanced CRUD operations for collections
+- `createAsyncOperation()` - Async operation management with loading/error states
+- `trackAsync()` - Track async operations in your state
+- `withSerialization()` - State persistence and SSR support
+- `withPersistence()` - Auto-save to localStorage/IndexedDB
 
 **Development Tools:**
 
-- `@signaltree/devtools` - Redux DevTools integration
-- `@signaltree/time-travel` - Undo/redo functionality
+- `withDevTools()` - Redux DevTools integration
+- `withTimeTravel()` - Undo/redo functionality
 
 **Integration:**
 
-- `@signaltree/ng-forms` - Angular Forms integration
-- `@signaltree/middleware` - State interceptors and logging
-- `@signaltree/presets` - Pre-configured common patterns
+- `withMiddleware()` - State interceptors and logging
+- `createLoggingMiddleware()` - Built-in logging middleware
+- `createValidationMiddleware()` - Built-in validation middleware
+
+**Presets:**
+
+- `createDevTree()` - Pre-configured development setup
+- `TREE_PRESETS` - Common configuration patterns
+
+#### Additional Packages
+
+These are the **only** separate packages in the SignalTree ecosystem:
+
+- **`@signaltree/ng-forms`** - Angular Forms integration (separate package)
+- **`@signaltree/enterprise`** - Enterprise-scale optimizations for 500+ signals (separate package)
+- **`@signaltree/callable-syntax`** - Build-time transform for callable syntax (dev dependency, separate package)
 
 #### Composition Patterns
 
 **Basic Enhancement:**
 
 ```typescript
-import { signalTree } from '@signaltree/core';
-import { withBatching } from '@signaltree/core';
-import { withDevTools } from '@signaltree/core';
+import { signalTree, withBatching, withDevTools } from '@signaltree/core';
 
 // Apply enhancers in order
 const tree = signalTree({ count: 0 }).with(
@@ -511,9 +528,7 @@ const tree = signalTree({ count: 0 }).with(
 **Performance-Focused Stack:**
 
 ```typescript
-import { signalTree, withBatching } from '@signaltree/core';
-import { withMemoization } from '@signaltree/core';
-import { withEntities } from '@signaltree/core';
+import { signalTree, withBatching, withMemoization, withEntities } from '@signaltree/core';
 
 const tree = signalTree({
   products: [] as Product[],
@@ -537,8 +552,7 @@ products.selectBy((p) => p.category === 'electronics');
 **Full-Stack Application:**
 
 ```typescript
-import { withSerialization } from '@signaltree/core';
-import { withTimeTravel } from '@signaltree/core';
+import { signalTree, withSerialization, withTimeTravel } from '@signaltree/core';
 
 const tree = signalTree({
   user: null as User | null,
@@ -585,36 +599,34 @@ const tree = signalTree(state).with(
 For common patterns, use presets that combine multiple enhancers:
 
 ```typescript
-import { ecommercePreset, dashboardPreset } from '@signaltree/core';
+import { createDevTree, TREE_PRESETS } from '@signaltree/core';
 
-// E-commerce preset includes: entities, async, batching, serialization
-const ecommerceTree = ecommercePreset({
+// Development preset includes: batching, memoization, devtools, time-travel
+const devTree = createDevTree({
   products: [] as Product[],
   cart: { items: [], total: 0 },
 });
 
-// Dashboard preset includes: batching, memoization, devtools
-const dashboardTree = dashboardPreset({
-  metrics: { users: 0, revenue: 0 },
-  charts: { data: [] },
-});
+// Or use preset configurations
+const customTree = signalTree(state, TREE_PRESETS.DASHBOARD);
 ```
 
 #### Core Stubs
 
-SignalTree Core includes lightweight stubs for all enhancer methods. This allows you to write code that uses advanced features, and the methods will warn when the actual enhancer isn't installed:
+SignalTree Core includes all enhancer functionality built-in. No separate packages needed:
 
 ```typescript
+import { signalTree, withEntities } from '@signaltree/core';
+
 const tree = signalTree({ users: [] as User[] });
 
-// Works but warns: "Feature requires @signaltree/entities"
-const users = tree.entities<User>('users');
-users.add(newUser); // Warns: "Method requires @signaltree/entities"
+// Without enhancer - use manual CRUD
+tree.$.users.update((users) => [...users, newUser]);
 
-// Install the enhancer to enable full functionality
+// With enhancer - use entity helpers
 const enhanced = tree.with(withEntities());
-const realUsers = enhanced.entities<User>('users');
-realUsers.add(newUser); // ✅ Works perfectly
+const users = enhanced.entities<User>('users');
+users.add(newUser); // ✅ Advanced CRUD operations
 ```
 
 Core includes several performance optimizations:
@@ -775,9 +787,7 @@ tree.effect(() => console.log('State changed'));
 ### Performance-Enhanced Composition
 
 ```typescript
-import { signalTree } from '@signaltree/core';
-import { withBatching } from '@signaltree/core';
-import { withMemoization } from '@signaltree/core';
+import { signalTree, withBatching, withMemoization } from '@signaltree/core';
 
 // Add performance optimizations
 const tree = signalTree({
@@ -805,8 +815,7 @@ const filteredProducts = computed(() => {
 ### Data Management Composition
 
 ```typescript
-import { signalTree } from '@signaltree/core';
-import { withEntities } from '@signaltree/core';
+import { signalTree, withEntities } from '@signaltree/core';
 
 // Add data management capabilities (+2.77KB total)
 const tree = signalTree({
@@ -834,12 +843,7 @@ const fetchUsers = tree.asyncAction(async () => api.getUsers(), {
 ### Full-Featured Development Composition
 
 ```typescript
-import { signalTree } from '@signaltree/core';
-import { withBatching } from '@signaltree/core';
-import { withEntities } from '@signaltree/core';
-import { withSerialization } from '@signaltree/core';
-import { withTimeTravel } from '@signaltree/core';
-import { withDevTools } from '@signaltree/core';
+import { signalTree, withBatching, withEntities, withSerialization, withTimeTravel, withDevTools } from '@signaltree/core';
 
 // Full development stack (example)
 const tree = signalTree({
@@ -878,10 +882,7 @@ tree.save(); // Persistence
 ### Production-Ready Composition
 
 ```typescript
-import { signalTree } from '@signaltree/core';
-import { withBatching } from '@signaltree/core';
-import { withEntities } from '@signaltree/core';
-import { withSerialization } from '@signaltree/core';
+import { signalTree, withBatching, withEntities, withSerialization } from '@signaltree/core';
 
 // Production build (no dev tools)
 const tree = signalTree(initialState).with(
@@ -902,9 +903,7 @@ const tree = signalTree(initialState).with(
 ### Conditional Enhancement
 
 ```typescript
-import { signalTree } from '@signaltree/core';
-import { withDevTools } from '@signaltree/core';
-import { withTimeTravel } from '@signaltree/core';
+import { signalTree, withBatching, withEntities, withDevTools, withTimeTravel } from '@signaltree/core';
 
 const isDevelopment = process.env['NODE_ENV'] === 'development';
 
@@ -925,22 +924,19 @@ const tree = signalTree(state).with(
 ### Preset-Based Composition
 
 ```typescript
-import { ecommercePreset, dashboardPreset } from '@signaltree/core';
+import { createDevTree, TREE_PRESETS } from '@signaltree/core';
 
 // Use presets for common patterns
-const ecommerceTree = ecommercePreset({
+const devTree = createDevTree({
   products: [],
   cart: { items: [], total: 0 },
   user: null,
 });
-// Includes: entities, async, batching, serialization
+// Includes: batching, memoization, devtools, time-travel
 
-const dashboardTree = dashboardPreset({
-  metrics: {},
-  charts: [],
-  filters: {},
-});
-// Includes: batching, memoization, devtools
+// Or use preset configurations directly
+const customTree = signalTree(state, TREE_PRESETS.PERFORMANCE);
+// Includes: batching, memoization optimizations
 ```
 
 ### Measuring bundle size
@@ -1247,29 +1243,25 @@ tree.effect(fn); // Create reactive effects
 tree.subscribe(fn); // Manual subscriptions
 tree.destroy(); // Cleanup resources
 
-// Extended features (require additional packages)
-tree.entities<T>(key); // Entity helpers (requires @signaltree/entities)
-// tree.asyncAction(fn, config?) example removed — use middleware helpers instead
-tree.asyncAction(fn, config?); // Create async action
+// Extended features (built into @signaltree/core)
+tree.entities<T>(key); // Entity helpers (use withEntities enhancer)
+tree.asyncAction(fn, config?); // Async operations (use createAsyncOperation helper)
 ```
 
-## Extending with optional packages
+## Extending with enhancers
 
-SignalTree Core can be extended with additional features:
+SignalTree Core includes all enhancers built-in:
 
 ```typescript
-import { signalTree } from '@signaltree/core';
-import { withBatching } from '@signaltree/core';
-import { withMemoization } from '@signaltree/core';
-import { withTimeTravel } from '@signaltree/core';
+import { signalTree, withBatching, withMemoization, withTimeTravel } from '@signaltree/core';
 
-// Compose features using .with(...)
+// All enhancers available from @signaltree/core
 const tree = signalTree(initialState).with(withBatching(), withMemoization(), withTimeTravel());
 ```
 
-### Available extensions
+### Available enhancers
 
-All enhancers are now consolidated in the core package:
+All enhancers are included in `@signaltree/core`:
 
 - **withBatching()** - Batch multiple updates for better performance
 - **withMemoization()** - Intelligent caching & performance optimization
@@ -1278,8 +1270,8 @@ All enhancers are now consolidated in the core package:
 - **withDevTools()** - Redux DevTools integration for debugging
 - **withTimeTravel()** - Undo/redo functionality & state history
 - **withSerialization()** - State persistence & SSR support
-- **ecommercePreset()** - Pre-configured setup for e-commerce applications
-- **dashboardPreset()** - Pre-configured setup for dashboard applications
+- **createDevTree()** - Pre-configured development setup
+- **TREE_PRESETS** - Common configuration patterns (PERFORMANCE, DASHBOARD, etc.)
 
 ## When to use core only
 
@@ -1291,12 +1283,18 @@ Perfect for:
 - ✅ Learning signal-based state management
 - ✅ Applications with basic state needs
 
-Consider extensions when you need:
+Consider enhancers when you need:
+
+- ⚡ Performance optimization (withBatching, withMemoization)
+- 🐛 Advanced debugging (withDevTools, withTimeTravel)
+- � Entity management (withEntities)
+- 🔌 Middleware patterns (withMiddleware)
+
+Consider separate packages when you need:
 
-- ⚡ Performance optimization (batching, memoization)
-- 🐛 Advanced debugging (devtools, time-travel)
-- 📝 Complex forms (ng-forms)
-- 🔧 Middleware patterns (middleware)
+- 📝 Angular forms integration (@signaltree/ng-forms)
+- 🏢 Enterprise-scale optimizations (@signaltree/enterprise)
+- 🎯 Callable syntax transform (@signaltree/callable-syntax)
 
 ## Migration from NgRx
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signaltree/core",
-  "version": "4.0.7",
+  "version": "4.0.9",
   "description": "Lightweight, type-safe signal-based state management for Angular. Core package providing hierarchical signal trees, basic entity management, and async actions.",
   "type": "module",
   "sideEffects": false,
@@ -65,7 +65,7 @@
     "tslib": "*"
   },
   "dependencies": {
-    "@signaltree/shared": "workspace:*"
+    "@signaltree/shared": "0.0.1"
   },
   "files": [
     "dist",