@signaltree/core 6.3.0 → 7.0.0

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/dist/enhancers/entities/entities.js

@@ -1,38 +1,11 @@
-import { createEntitySignal } from '../../lib/entity-signal.js';
-import { getPathNotifier } from '../../lib/path-notifier.js';
-
-function isEntityMapMarker(value) {
-  return Boolean(value && typeof value === 'object' && value['__isEntityMap'] === true);
-}
 function entities(config = {}) {
+  if (typeof ngDevMode === 'undefined' || ngDevMode) {
+    console.warn('SignalTree: entities() enhancer is deprecated in v7. ' + 'EntityMap markers are now automatically processed. ' + 'Remove .with(entities()) from your code. ' + 'This enhancer will be removed in v8.');
+  }
   const {
     enabled = true
   } = config;
   return tree => {
-    if (!enabled) {
-      tree.__entitiesEnabled = true;
-      return tree;
-    }
-    const notifier = getPathNotifier();
-    function materialize(node, path = []) {
-      if (!node || typeof node !== 'object') return;
-      for (const [k, v] of Object.entries(node)) {
-        if (isEntityMapMarker(v)) {
-          const cfg = v.__entityMapConfig ?? {};
-          const sig = createEntitySignal(cfg, notifier, path.concat(k).join('.'));
-          try {
-            node[k] = sig;
-          } catch {}
-          try {
-            tree[k] = sig;
-          } catch {}
-        } else if (typeof v === 'object' && v !== null && !Array.isArray(v)) {
-          materialize(v, path.concat(k));
-        }
-      }
-    }
-    materialize(tree.state);
-    materialize(tree.$);
     tree.__entitiesEnabled = true;
     return tree;
   };

package/dist/index.js

@@ -1,5 +1,9 @@
 export { signalTree } from './lib/signal-tree.js';
 export { ENHANCER_META, entityMap } from './lib/types.js';
+export { isDerivedMarker } from './lib/markers/derived.js';
+export { LoadingState, isStatusMarker, status } from './lib/markers/status.js';
+export { isStoredMarker, stored } from './lib/markers/stored.js';
+export { registerMarkerProcessor } from './lib/internals/materialize-markers.js';
 export { composeEnhancers, createLazySignalTree, isAnySignal, isNodeAccessor, toWritableSignal } from './lib/utils.js';
 export { createEditSession } from './lib/edit-session.js';
 export { getPathNotifier } from './lib/path-notifier.js';

package/dist/lib/internals/batch-scope.js

@@ -0,0 +1,8 @@
+function batchScope(fn) {
+  try {
+    fn();
+  } finally {
+  }
+}
+
+export { batchScope };

package/dist/lib/internals/materialize-markers.js

@@ -0,0 +1,66 @@
+import { isSignal } from '@angular/core';
+import { createEntitySignal } from '../entity-signal.js';
+import { createStatusSignal, isStatusMarker } from '../markers/status.js';
+import { createStoredSignal, isStoredMarker } from '../markers/stored.js';
+import { getPathNotifier } from '../path-notifier.js';
+import { isNodeAccessor } from '../utils.js';
+
+function isEntityMapMarker(value) {
+  return Boolean(value && typeof value === 'object' && value['__isEntityMap'] === true);
+}
+const MARKER_PROCESSORS = [];
+function registerMarkerProcessor(check, create) {
+  MARKER_PROCESSORS.push({
+    check,
+    create: create
+  });
+}
+registerMarkerProcessor(isEntityMapMarker, (marker, notifier, path) => {
+  const cfg = marker.__entityMapConfig ?? {};
+  return createEntitySignal(cfg, notifier, path);
+});
+registerMarkerProcessor(isStatusMarker, marker => createStatusSignal(marker));
+registerMarkerProcessor(isStoredMarker, marker => createStoredSignal(marker));
+function materializeMarkers(node, notifier, path = []) {
+  if (node == null) return;
+  if (typeof node !== 'object' && typeof node !== 'function') return;
+  if (isSignal(node)) return;
+  const isAccessor = typeof node === 'function' && isNodeAccessor(node);
+  if (typeof node === 'function' && !isAccessor) return;
+  const getNotifier = () => {
+    if (!notifier) {
+      notifier = getPathNotifier();
+    }
+    return notifier;
+  };
+  const keys = Object.keys(node);
+  for (const key of keys) {
+    const value = node[key];
+    const currentPath = [...path, key];
+    const pathString = currentPath.join('.');
+    let processed = false;
+    for (const processor of MARKER_PROCESSORS) {
+      if (processor.check(value)) {
+        try {
+          const materialized = processor.create(value, getNotifier(), pathString);
+          node[key] = materialized;
+          processed = true;
+        } catch (err) {
+          if (typeof ngDevMode === 'undefined' || ngDevMode) {
+            console.error(`SignalTree: Failed to materialize marker at "${pathString}"`, err);
+          }
+        }
+        break;
+      }
+    }
+    if (!processed && value != null) {
+      if (isNodeAccessor(value)) {
+        materializeMarkers(value, notifier, currentPath);
+      } else if (typeof value === 'object' && !Array.isArray(value) && !isSignal(value)) {
+        materializeMarkers(value, notifier, currentPath);
+      }
+    }
+  }
+}
+
+export { materializeMarkers, registerMarkerProcessor };

package/dist/lib/internals/merge-derived.js

@@ -0,0 +1,59 @@
+import { computed, isSignal } from '@angular/core';
+import { isDerivedMarker } from '../markers/derived.js';
+
+function isSignalLike(value) {
+  return isSignal(value);
+}
+function ensurePathAndGetTarget($, path) {
+  if (!path) return $;
+  const parts = path.split('.');
+  let current = $;
+  for (const part of parts) {
+    if (!(part in current)) {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  return current;
+}
+function mergeDerivedState($, derivedDef, path = '') {
+  if (!derivedDef || typeof derivedDef !== 'object') {
+    return;
+  }
+  for (const [key, value] of Object.entries(derivedDef)) {
+    const currentPath = path ? `${path}.${key}` : key;
+    if (isDerivedMarker(value)) {
+      const target = ensurePathAndGetTarget($, path);
+      if (key in target && isSignalLike(target[key])) {
+        if (typeof ngDevMode === 'undefined' || ngDevMode) {
+          console.warn(`SignalTree: Derived "${currentPath}" overwrites source signal. ` + `Consider using a different key to avoid confusion.`);
+        }
+      }
+      target[key] = computed(value.factory);
+    } else if (isSignalLike(value)) {
+      const target = ensurePathAndGetTarget($, path);
+      if (key in target && isSignalLike(target[key])) {
+        if (typeof ngDevMode === 'undefined' || ngDevMode) {
+          console.warn(`SignalTree: Derived signal "${currentPath}" overwrites source signal. ` + `Consider using a different key to avoid confusion.`);
+        }
+      }
+      target[key] = value;
+    } else if (typeof value === 'object' && value !== null) {
+      const target = ensurePathAndGetTarget($, path);
+      if (!(key in target)) {
+        target[key] = {};
+      } else if (isSignalLike(target[key])) {
+        throw new Error(`SignalTree: Cannot merge derived object into "${currentPath}" ` + `because source is a signal. Either make source an object or use a different key.`);
+      }
+      mergeDerivedState($, value, currentPath);
+    }
+  }
+}
+function applyDerivedFactories($, factories) {
+  for (const factory of factories) {
+    const derivedDef = factory($);
+    mergeDerivedState($, derivedDef);
+  }
+}
+
+export { applyDerivedFactories, mergeDerivedState };

package/dist/lib/markers/derived.js

@@ -0,0 +1,6 @@
+const DERIVED_MARKER = Symbol.for('signaltree:derived');
+function isDerivedMarker(value) {
+  return value !== null && typeof value === 'object' && DERIVED_MARKER in value && value[DERIVED_MARKER] === true;
+}
+
+export { isDerivedMarker };

package/dist/lib/markers/status.js

@@ -0,0 +1,65 @@
+import { signal, computed } from '@angular/core';
+
+const STATUS_MARKER = Symbol('STATUS_MARKER');
+var LoadingState;
+(function (LoadingState) {
+  LoadingState["NotLoaded"] = "NOT_LOADED";
+  LoadingState["Loading"] = "LOADING";
+  LoadingState["Loaded"] = "LOADED";
+  LoadingState["Error"] = "ERROR";
+})(LoadingState || (LoadingState = {}));
+function status(initialState = LoadingState.NotLoaded) {
+  return {
+    [STATUS_MARKER]: true,
+    initialState
+  };
+}
+function isStatusMarker(value) {
+  return value !== null && typeof value === 'object' && STATUS_MARKER in value && value[STATUS_MARKER] === true;
+}
+function createStatusSignal(marker) {
+  const stateSignal = signal(marker.initialState);
+  const errorSignal = signal(null);
+  let _isNotLoaded = null;
+  let _isLoading = null;
+  let _isLoaded = null;
+  let _isError = null;
+  return {
+    state: stateSignal,
+    error: errorSignal,
+    get isNotLoaded() {
+      return _isNotLoaded ??= computed(() => stateSignal() === LoadingState.NotLoaded);
+    },
+    get isLoading() {
+      return _isLoading ??= computed(() => stateSignal() === LoadingState.Loading);
+    },
+    get isLoaded() {
+      return _isLoaded ??= computed(() => stateSignal() === LoadingState.Loaded);
+    },
+    get isError() {
+      return _isError ??= computed(() => stateSignal() === LoadingState.Error);
+    },
+    setNotLoaded() {
+      stateSignal.set(LoadingState.NotLoaded);
+      errorSignal.set(null);
+    },
+    setLoading() {
+      stateSignal.set(LoadingState.Loading);
+      errorSignal.set(null);
+    },
+    setLoaded() {
+      stateSignal.set(LoadingState.Loaded);
+      errorSignal.set(null);
+    },
+    setError(err) {
+      stateSignal.set(LoadingState.Error);
+      errorSignal.set(err);
+    },
+    reset() {
+      stateSignal.set(LoadingState.NotLoaded);
+      errorSignal.set(null);
+    }
+  };
+}
+
+export { LoadingState, STATUS_MARKER, createStatusSignal, isStatusMarker, status };

package/dist/lib/markers/stored.js

@@ -0,0 +1,105 @@
+import { signal } from '@angular/core';
+
+const STORED_MARKER = Symbol('STORED_MARKER');
+function stored(key, defaultValue, options = {}) {
+  return {
+    [STORED_MARKER]: true,
+    key,
+    defaultValue,
+    options
+  };
+}
+function isStoredMarker(value) {
+  return value !== null && typeof value === 'object' && STORED_MARKER in value && value[STORED_MARKER] === true;
+}
+function createStoredSignal(marker) {
+  const {
+    key,
+    defaultValue,
+    options: {
+      serialize = JSON.stringify,
+      deserialize = JSON.parse,
+      debounceMs = 100
+    }
+  } = marker;
+  const storage = marker.options.storage !== undefined ? marker.options.storage : typeof localStorage !== 'undefined' ? localStorage : null;
+  let initialValue = defaultValue;
+  if (storage) {
+    try {
+      const storedValue = storage.getItem(key);
+      if (storedValue !== null) {
+        initialValue = deserialize(storedValue);
+      }
+    } catch (e) {
+      if (typeof ngDevMode === 'undefined' || ngDevMode) {
+        console.warn(`SignalTree: Failed to read "${key}" from storage`, e);
+      }
+    }
+  }
+  const sig = signal(initialValue);
+  let pendingWrite = null;
+  let pendingValue;
+  const saveToStorage = value => {
+    if (!storage) return;
+    if (debounceMs === 0) {
+      queueMicrotask(() => {
+        try {
+          storage.setItem(key, serialize(value));
+        } catch (e) {
+          if (typeof ngDevMode === 'undefined' || ngDevMode) {
+            console.warn(`SignalTree: Failed to save "${key}" to storage`, e);
+          }
+        }
+      });
+      return;
+    }
+    pendingValue = value;
+    if (pendingWrite !== null) {
+      clearTimeout(pendingWrite);
+    }
+    pendingWrite = setTimeout(() => {
+      pendingWrite = null;
+      queueMicrotask(() => {
+        try {
+          storage.setItem(key, serialize(pendingValue));
+        } catch (e) {
+          if (typeof ngDevMode === 'undefined' || ngDevMode) {
+            console.warn(`SignalTree: Failed to save "${key}" to storage`, e);
+          }
+        }
+      });
+    }, debounceMs);
+  };
+  const storedSignal = () => sig();
+  storedSignal.set = value => {
+    sig.set(value);
+    saveToStorage(value);
+  };
+  storedSignal.update = fn => {
+    const newValue = fn(sig());
+    sig.set(newValue);
+    saveToStorage(newValue);
+  };
+  storedSignal.clear = () => {
+    sig.set(defaultValue);
+    if (storage) {
+      storage.removeItem(key);
+    }
+  };
+  storedSignal.reload = () => {
+    if (!storage) return;
+    try {
+      const storedValue = storage.getItem(key);
+      if (storedValue !== null) {
+        sig.set(deserialize(storedValue));
+      } else {
+        sig.set(defaultValue);
+      }
+    } catch {
+      sig.set(defaultValue);
+    }
+  };
+  return storedSignal;
+}
+
+export { STORED_MARKER, createStoredSignal, isStoredMarker, stored };

package/dist/lib/signal-tree.js

@@ -1,5 +1,10 @@
 import { signal, isSignal } from '@angular/core';
 import { SIGNAL_TREE_MESSAGES, SIGNAL_TREE_CONSTANTS } from './constants.js';
+import { batchScope } from './internals/batch-scope.js';
+import { materializeMarkers } from './internals/materialize-markers.js';
+import { applyDerivedFactories } from './internals/merge-derived.js';
+import { isStatusMarker } from './markers/status.js';
+import { isStoredMarker } from './markers/stored.js';
 import { SignalMemoryManager } from './memory/memory-manager.js';
 import { getPathNotifier } from './path-notifier.js';
 import { SecurityValidator } from './security/security-validator.js';
@@ -88,16 +93,21 @@ function makeNodeAccessor(store) {
     if (typeof arg === 'function') {
       const updater = arg;
       const current = unwrap(store);
-      recursiveUpdate(store, updater(current));
-    } else {
-      recursiveUpdate(store, arg);
+      batchScope(() => recursiveUpdate(store, updater(current)));
+      return;
+    }
+    if (typeof arg === 'object' && arg !== null && !Array.isArray(arg)) {
+      batchScope(() => recursiveUpdate(store, arg));
+      return;
     }
+    recursiveUpdate(store, arg);
   };
   accessor[NODE_ACCESSOR_SYMBOL] = true;
   for (const key of Object.keys(store)) {
     Object.defineProperty(accessor, key, {
       value: store[key],
       enumerable: true,
+      writable: true,
       configurable: true
     });
   }
@@ -142,6 +152,14 @@ function createSignalStore(obj, equalityFn) {
       store[key] = value;
       continue;
     }
+    if (isStatusMarker(value)) {
+      store[key] = value;
+      continue;
+    }
+    if (isStoredMarker(value)) {
+      store[key] = value;
+      continue;
+    }
     if (isSignal(value)) {
       store[key] = value;
       continue;
@@ -275,8 +293,114 @@ function create(initialState, config) {
   }
   return tree;
 }
-function signalTree(initialState, config = {}) {
-  return create(initialState, config);
+function signalTree(initialState, configOrDerived) {
+  const isFactory = typeof configOrDerived === 'function';
+  const config = isFactory ? {} : configOrDerived ?? {};
+  const baseTree = create(initialState, config);
+  const builder = createBuilder(baseTree);
+  if (isFactory) {
+    return builder.derived(configOrDerived);
+  }
+  return builder;
+}
+function createBuilder(baseTree) {
+  const derivedQueue = [];
+  let isFinalized = false;
+  const finalize = () => {
+    if (isFinalized) return;
+    isFinalized = true;
+    materializeMarkers(baseTree.$);
+    materializeMarkers(baseTree.state);
+    if (derivedQueue.length > 0) {
+      applyDerivedFactories(baseTree.$, derivedQueue);
+    }
+  };
+  const builder = function (arg) {
+    if (arguments.length === 0) {
+      return baseTree();
+    }
+    return baseTree(arg);
+  };
+  builder[NODE_ACCESSOR_SYMBOL] = true;
+  Object.defineProperty(builder, 'state', {
+    get() {
+      finalize();
+      return baseTree.state;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(builder, '$', {
+    get() {
+      finalize();
+      return baseTree.$;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(builder, 'with', {
+    value: function (enhancer) {
+      const enhanced = baseTree.with(enhancer);
+      const newBuilder = createBuilder(enhanced);
+      for (const key of Object.keys(enhanced)) {
+        if (key !== '$' && key !== 'state' && key !== 'with' && key !== 'bind' && key !== 'destroy' && key !== 'derived') {
+          try {
+            newBuilder[key] = enhanced[key];
+          } catch {}
+        }
+      }
+      for (const factory of derivedQueue) {
+        newBuilder.derived(factory);
+      }
+      return newBuilder;
+    },
+    enumerable: false,
+    writable: false,
+    configurable: true
+  });
+  if (typeof baseTree.bind === 'function') {
+    Object.defineProperty(builder, 'bind', {
+      value: baseTree.bind.bind(baseTree),
+      enumerable: false,
+      writable: false,
+      configurable: true
+    });
+  } else {
+    Object.defineProperty(builder, 'bind', {
+      value: () => builder,
+      enumerable: false,
+      writable: false,
+      configurable: true
+    });
+  }
+  if (typeof baseTree.destroy === 'function') {
+    Object.defineProperty(builder, 'destroy', {
+      value: baseTree.destroy.bind(baseTree),
+      enumerable: false,
+      writable: true,
+      configurable: true
+    });
+  } else {
+    Object.defineProperty(builder, 'destroy', {
+      value: () => {},
+      enumerable: false,
+      writable: true,
+      configurable: true
+    });
+  }
+  Object.defineProperty(builder, 'derived', {
+    value: function (factory) {
+      if (isFinalized) {
+        throw new Error('SignalTree: Cannot add derived() after tree.$ has been accessed. ' + 'Chain all .derived() calls before accessing $.');
+      }
+      derivedQueue.push(factory);
+      return builder;
+    },
+    enumerable: false,
+    writable: false,
+    configurable: true
+  });
+  return builder;
 }
 
 export { isNodeAccessor, signalTree };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signaltree/core",
-  "version": "6.3.0",
+  "version": "7.0.0",
   "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,
@@ -89,4 +89,4 @@
     "src/**/*.d.ts",
     "README.md"
   ]
-}
+}

package/src/index.d.ts

@@ -1,6 +1,12 @@
 export { signalTree } from './lib/signal-tree';
 export type { ISignalTree, SignalTree, SignalTreeBase, FullSignalTree, ProdSignalTree, TreeNode, CallableWritableSignal, AccessibleNode, NodeAccessor, Primitive, NotFn, TreeConfig, TreePreset, Enhancer, EnhancerMeta, EnhancerWithMeta, EntitySignal, EntityMapMarker, EntityConfig, MutationOptions, AddOptions, AddManyOptions, TimeTravelEntry, TimeTravelMethods, } from './lib/types';
 export { entityMap } from './lib/types';
+export type { ProcessDerived, DeepMergeTree, DerivedFactory, } from './lib/internals/derived-types';
+export type { SignalTreeBuilder } from './lib/internals/builder-types';
+export { isDerivedMarker, type DerivedMarker, type DerivedType, } from './lib/markers/derived';
+export { status, isStatusMarker, LoadingState, type StatusMarker, type StatusSignal, type StatusConfig, } from './lib/markers/status';
+export { stored, isStoredMarker, type StoredMarker, type StoredSignal, type StoredOptions, } from './lib/markers/stored';
+export { registerMarkerProcessor } from './lib/internals/materialize-markers';
 export { equal, deepEqual, isNodeAccessor, isAnySignal, toWritableSignal, parsePath, composeEnhancers, isBuiltInObject, createLazySignalTree, } from './lib/utils';
 export { createEditSession, type EditSession, type UndoRedoHistory, } from './lib/edit-session';
 export { getPathNotifier } from './lib/path-notifier';

package/src/lib/internals/batch-scope.d.ts

@@ -0,0 +1,3 @@
+export declare function batchScope(fn: () => void): void;
+export declare function isInBatchScope(): boolean;
+export declare function getBatchDepth(): number;

package/src/lib/internals/builder-types.d.ts

@@ -0,0 +1,13 @@
+import type { ProcessDerived } from './derived-types';
+import type { ISignalTree, TreeNode } from '../types';
+export interface SignalTreeBuilder<TSource, TAccum = TreeNode<TSource>> {
+    (): TSource;
+    (value: Partial<TSource>): void;
+    (updater: (current: TSource) => TSource): void;
+    readonly $: TAccum;
+    readonly state: TAccum;
+    with<TAdded>(enhancer: (tree: ISignalTree<TSource>) => ISignalTree<TSource> & TAdded): SignalTreeBuilder<TSource, TAccum> & TAdded;
+    bind(thisArg?: unknown): (value?: TSource) => TSource | void;
+    destroy(): void;
+    derived<TDerived extends object>(factory: ($: TAccum) => TDerived): SignalTreeBuilder<TSource, TAccum & ProcessDerived<TDerived>>;
+}

package/src/lib/internals/derived-types.d.ts

@@ -0,0 +1,10 @@
+import { Signal } from '@angular/core';
+import type { DerivedMarker } from '../markers/derived';
+import type { TreeNode } from '../types';
+export type ProcessDerived<T> = T extends DerivedMarker<infer R> ? Signal<R> : T extends Signal<infer S> ? Signal<S> : T extends object ? {
+    [P in keyof T]: ProcessDerived<T[P]>;
+} : never;
+export type DeepMergeTree<TSource, TDerived> = {
+    [K in keyof TSource | keyof TDerived]: K extends keyof TSource ? K extends keyof TDerived ? TSource[K] extends object ? TDerived[K] extends object ? TDerived[K] extends DerivedMarker<infer R> ? Signal<R> : TSource[K] & DeepMergeTree<TSource[K], ProcessDerived<TDerived[K]>> : TSource[K] : ProcessDerived<TDerived[K]> : TSource[K] : K extends keyof TDerived ? ProcessDerived<TDerived[K]> : never;
+};
+export type DerivedFactory<TSource, TDerived> = ($: TreeNode<TSource>) => TDerived;

package/src/lib/internals/materialize-markers.d.ts

@@ -0,0 +1,4 @@
+import { PathNotifier } from '../path-notifier';
+export declare function registerMarkerProcessor<T, R>(check: (value: unknown) => value is T, create: (marker: T, notifier: PathNotifier, path: string) => R): void;
+export declare function materializeMarkers(node: unknown, notifier?: PathNotifier, path?: string[]): void;
+export declare function hasMarkers(node: unknown, visited?: WeakSet<object>): boolean;

package/src/lib/internals/merge-derived.d.ts

@@ -0,0 +1,4 @@
+type AnyRecord = Record<string, unknown>;
+export declare function mergeDerivedState($: AnyRecord, derivedDef: unknown, path?: string): void;
+export declare function applyDerivedFactories($: AnyRecord, factories: Array<($: AnyRecord) => object>): void;
+export {};

package/src/lib/markers/derived.d.ts

@@ -0,0 +1,8 @@
+declare const DERIVED_MARKER: unique symbol;
+export interface DerivedMarker<T> {
+    readonly [DERIVED_MARKER]: true;
+    readonly factory: () => T;
+    readonly __type?: T;
+}
+export type DerivedType<T> = T extends DerivedMarker<infer R> ? R : never;
+export {};

package/src/lib/markers/index.d.ts

@@ -0,0 +1,3 @@
+export { isDerivedMarker, getDerivedMarkerSymbol, type DerivedMarker, type DerivedType, } from './derived';
+export { status, isStatusMarker, createStatusSignal, LoadingState, STATUS_MARKER, type StatusMarker, type StatusSignal, type StatusConfig, } from './status';
+export { stored, isStoredMarker, createStoredSignal, STORED_MARKER, type StoredMarker, type StoredSignal, type StoredOptions, } from './stored';

package/src/lib/markers/status.d.ts

@@ -0,0 +1,31 @@
+import { Signal, WritableSignal } from '@angular/core';
+export declare const STATUS_MARKER: unique symbol;
+export declare enum LoadingState {
+    NotLoaded = "NOT_LOADED",
+    Loading = "LOADING",
+    Loaded = "LOADED",
+    Error = "ERROR"
+}
+export interface StatusConfig {
+    initialState?: LoadingState;
+}
+export interface StatusMarker {
+    [STATUS_MARKER]: true;
+    initialState: LoadingState;
+}
+export interface StatusSignal {
+    state: WritableSignal<LoadingState>;
+    error: WritableSignal<Error | null>;
+    isNotLoaded: Signal<boolean>;
+    isLoading: Signal<boolean>;
+    isLoaded: Signal<boolean>;
+    isError: Signal<boolean>;
+    setNotLoaded(): void;
+    setLoading(): void;
+    setLoaded(): void;
+    setError(error: Error): void;
+    reset(): void;
+}
+export declare function status(initialState?: LoadingState): StatusMarker;
+export declare function isStatusMarker(value: unknown): value is StatusMarker;
+export declare function createStatusSignal(marker: StatusMarker): StatusSignal;

package/src/lib/markers/stored.d.ts

@@ -0,0 +1,23 @@
+export declare const STORED_MARKER: unique symbol;
+export interface StoredOptions<T> {
+    serialize?: (value: T) => string;
+    deserialize?: (stored: string) => T;
+    storage?: Storage | null;
+    debounceMs?: number;
+}
+export interface StoredMarker<T> {
+    [STORED_MARKER]: true;
+    key: string;
+    defaultValue: T;
+    options: StoredOptions<T>;
+}
+export interface StoredSignal<T> {
+    (): T;
+    set(value: T): void;
+    update(fn: (current: T) => T): void;
+    clear(): void;
+    reload(): void;
+}
+export declare function stored<T>(key: string, defaultValue: T, options?: StoredOptions<T>): StoredMarker<T>;
+export declare function isStoredMarker(value: unknown): value is StoredMarker<unknown>;
+export declare function createStoredSignal<T>(marker: StoredMarker<T>): StoredSignal<T>;

package/src/lib/signal-tree.d.ts

@@ -1,3 +1,6 @@
-import type { TreeConfig, NodeAccessor, ISignalTree } from './types';
+import { SignalTreeBuilder } from './internals/builder-types';
+import { ProcessDerived } from './internals/derived-types';
+import type { TreeNode, TreeConfig, NodeAccessor } from './types';
 export declare function isNodeAccessor(value: unknown): value is NodeAccessor<unknown>;
-export declare function signalTree<T extends object>(initialState: T, config?: TreeConfig): ISignalTree<T>;
+export declare function signalTree<T extends object, TDerived extends object>(initialState: T, derivedFactory: ($: TreeNode<T>) => TDerived): SignalTreeBuilder<T, TreeNode<T> & ProcessDerived<TDerived>>;
+export declare function signalTree<T extends object>(initialState: T, config?: TreeConfig): SignalTreeBuilder<T, TreeNode<T>>;

package/src/lib/types.d.ts

@@ -1,4 +1,6 @@
 import { Signal, WritableSignal } from '@angular/core';
+import { StatusMarker, StatusSignal } from './markers/status';
+import { StoredMarker, StoredSignal } from './markers/stored';
 import { SecurityValidatorConfig } from './security/security-validator';
 export interface TimeTravelConfig {
     enabled?: boolean;
@@ -28,11 +30,11 @@ declare module '@angular/core' {
 }
 export interface NodeAccessor<T> {
     (): T;
-    (value: T): void;
+    (value: Partial<T>): void;
     (updater: (current: T) => T): void;
 }
 export type TreeNode<T> = {
-    [K in keyof T]: T[K] extends EntityMapMarker<infer E, infer Key> ? EntitySignal<E, Key> : T[K] extends Primitive ? CallableWritableSignal<T[K]> : T[K] extends readonly unknown[] ? CallableWritableSignal<T[K]> : T[K] extends Date | RegExp | Map<any, any> | Set<any> | Error | ((...args: unknown[]) => unknown) ? CallableWritableSignal<T[K]> : T[K] extends object ? NodeAccessor<T[K]> & TreeNode<T[K]> : CallableWritableSignal<T[K]>;
+    [K in keyof T]: T[K] extends EntityMapMarker<infer E, infer Key> ? EntitySignal<E, Key> : T[K] extends StatusMarker ? StatusSignal : T[K] extends StoredMarker<infer V> ? StoredSignal<V> : T[K] extends Primitive ? CallableWritableSignal<T[K]> : T[K] extends readonly unknown[] ? CallableWritableSignal<T[K]> : T[K] extends Date | RegExp | Map<any, any> | Set<any> | Error | ((...args: unknown[]) => unknown) ? CallableWritableSignal<T[K]> : T[K] extends object ? NodeAccessor<T[K]> & TreeNode<T[K]> : CallableWritableSignal<T[K]>;
 };
 export interface ISignalTree<T> extends NodeAccessor<T> {
     readonly state: TreeNode<T>;

package/src/lib/utils.d.ts

@@ -1,4 +1,4 @@
-import { Signal, WritableSignal } from '@angular/core';
+import { WritableSignal } from '@angular/core';
 import { deepEqual, isBuiltInObject, parsePath } from '@signaltree/shared';
 export { deepEqual };
 export { deepEqual as equal };
@@ -10,14 +10,7 @@ export interface MemoryManager {
     cacheSignal(path: string, signal: WritableSignal<unknown>): void;
     dispose(): void;
 }
-export interface NodeAccessor<T> {
-    (): T;
-    (value: T): void;
-    (updater: (current: T) => T): void;
-}
-export type TreeNode<T> = {
-    [K in keyof T]: T[K] extends readonly unknown[] ? WritableSignal<T[K]> : T[K] extends object ? T[K] extends Signal<unknown> ? T[K] : T[K] extends (...args: unknown[]) => unknown ? WritableSignal<T[K]> : NodeAccessor<T[K]> : WritableSignal<T[K]>;
-};
+import type { NodeAccessor, TreeNode } from './types';
 export declare function isNodeAccessor(value: unknown): value is NodeAccessor<unknown>;
 export declare function isAnySignal(value: unknown): boolean;
 export declare function toWritableSignal<T>(node: NodeAccessor<T>, injector?: unknown): WritableSignal<T>;