preact-sigma 6.0.1 → 6.0.2

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { a as SigmaState, c as query, d as Draft, f as Immutable, i as SigmaRef, l as setAutoFreeze, m as Cleanup, n as Sigma, o as SigmaTarget, p as typeSymbol, r as SigmaDefinition, s as castProtected, t as Protected, u as sigma } from "./sigma-D1V3m1xk.mjs";
+import { a as SigmaState, c as query, d as Draft, f as Immutable, i as SigmaRef, l as setAutoFreeze, m as Cleanup, n as Sigma, o as SigmaTarget, p as typeSymbol, r as SigmaDefinition, s as castProtected, t as Protected, u as sigma } from "./sigma-BhmvUxp9.mjs";
 
 //#region src/defaults.d.ts
 /**

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { a as setAutoFreeze, c as listenersSymbol, i as query, n as SigmaTarget, o as sigma, r as castProtected, t as Sigma } from "./sigma-DTMODzf8.mjs";
+import { a as setAutoFreeze, c as listenersSymbol, i as query, n as SigmaTarget, o as sigma, r as castProtected, t as Sigma } from "./sigma-tZ0xhlG3.mjs";
 import { useEffect, useRef } from "preact/hooks";
 //#region src/defaults.ts
 /**

package/dist/persist.d.mts

@@ -1,4 +1,4 @@
-import { f as Immutable, n as Sigma } from "./sigma-D1V3m1xk.mjs";
+import { f as Immutable, n as Sigma } from "./sigma-BhmvUxp9.mjs";
 
 //#region src/persist.d.ts
 type MaybePromise<T> = T | Promise<T>;

package/dist/persist.mjs

@@ -1,4 +1,4 @@
-import { o as sigma, s as isPlainObject } from "./sigma-DTMODzf8.mjs";
+import { o as sigma, s as isPlainObject } from "./sigma-tZ0xhlG3.mjs";
 //#region src/persist.ts
 function createIdentityCodec() {
 	return {

package/dist/{sigma-D1V3m1xk.d.mts → sigma-BhmvUxp9.d.mts}

@@ -88,7 +88,8 @@ type SigmaState<T extends SigmaDefinition> = Sigma<T["state"]> & {
  * Base class for signal-backed state models.
  *
  * `TState` is the source of typing for top-level state keys, subscriptions, signals, and replacement snapshots.
- * Private class fields stay ordinary instance storage and are not signal-backed, captured, or persisted.
+ * Private class fields stay ordinary instance storage and are not signal-backed, captured,
+ * persisted, or used for reactive invalidation by themselves.
  * Merge a same-named interface with the class when direct property reads should be typed on the instance.
  */
 declare abstract class Sigma<TState extends object> {
@@ -146,7 +147,11 @@ declare const sigma: Readonly<{
   captureState<TState extends object>(instance: Sigma<TState>): Immutable<TState>; /** Publishes a plain-object snapshot as the current committed state. */
   replaceState<TState extends object>(target: Sigma<TState>, nextState: TState): void;
 }>;
-/** Marks a class method as a committed-state reactive read with arguments instead of an action. */
+/**
+ * Marks a class method as a committed-state reactive read with arguments instead of an action.
+ *
+ * Each call creates a reactive read at the call site. Query calls do not memoize results across invocations.
+ */
 declare function query<TThis extends object, TArgs extends any[], TReturn>(method: (this: TThis, ...args: TArgs) => TReturn): (this: TThis, ...args: TArgs) => TReturn;
 declare const protectedSymbol: unique symbol;
 type ProtectedKey = typeof listenersSymbol | typeof snapshotSymbol | "act" | "commit" | "emit" | "onSetup";

package/dist/{sigma-DTMODzf8.mjs → sigma-tZ0xhlG3.mjs}

@@ -322,7 +322,8 @@ function defineSignalProperty(instance, key, value) {
 * Base class for signal-backed state models.
 *
 * `TState` is the source of typing for top-level state keys, subscriptions, signals, and replacement snapshots.
-* Private class fields stay ordinary instance storage and are not signal-backed, captured, or persisted.
+* Private class fields stay ordinary instance storage and are not signal-backed, captured,
+* persisted, or used for reactive invalidation by themselves.
 * Merge a same-named interface with the class when direct property reads should be typed on the instance.
 */
 var Sigma = class {
@@ -443,7 +444,11 @@ const sigma = /* @__PURE__ */ Object.freeze({
 		publishState(instance, nextState, baseState, patches, inversePatches);
 	}
 });
-/** Marks a class method as a committed-state reactive read with arguments instead of an action. */
+/**
+* Marks a class method as a committed-state reactive read with arguments instead of an action.
+*
+* Each call creates a reactive read at the call site. Query calls do not memoize results across invocations.
+*/
 function query(method) {
 	queries.add(method);
 	function queryMethod(...args) {

package/docs/context.md

@@ -22,7 +22,7 @@
 - Sigma class: a class that extends `Sigma<TState>` and passes its initial top-level state to `super(...)`. The `TState` argument drives helper typing for subscriptions, signals, and replacement snapshots; a same-named merged interface gives direct property reads their instance types.
 - Sigma target: a class that extends `SigmaTarget<TEvents, TState>` when it also emits typed events. Use `SigmaTarget<TEvents>` for event-only targets.
 - State property: a top-level key from `TState`. Each key becomes a reactive public property and has its own signal.
-- Private field: an ECMAScript `#field` on the model class. Private fields are ordinary instance storage, not signal-backed state.
+- Private field: an ECMAScript `#field` on the model class. Private fields are ordinary instance storage. They can be read from model members, but they do not create signals or invalidate reactive reads by themselves.
 - Computed: an argument-free derived getter on the class prototype that reads committed state.
 - Query: a reactive read method that accepts arguments, is marked with the `query` decorator, and reads committed state.
 - Action: a prototype method that is not marked as a query. Actions read and write state properties through sigma's draft and commit semantics.
@@ -63,7 +63,7 @@
 
 - Put the state shape in a named `State` type, pass it to `Sigma<TState>` or `SigmaTarget<TEvents, TState>`, then merge a same-named interface with the class for direct property typing.
 - Keep frequently read values as separate top-level state properties. Each top-level key gets its own signal.
-- Use private fields for ephemeral caches, handles, or bookkeeping that should not be captured, restored, persisted, or used as subscription keys.
+- Use private fields for ephemeral caches, handles, or bookkeeping when private-only changes should not be captured, restored, persisted, used as subscription keys, or published reactively.
 - Use getters for argument-free derived reads.
 - Use `@query` for tracked reads with arguments.
 - Derive directly from state properties inside an action when the calculation needs unpublished draft values.
@@ -96,7 +96,7 @@
 # Invariants and Constraints
 
 - Sigma tracks top-level state properties. Each top-level key gets its own signal.
-- Private fields are not top-level state properties. They do not create signals, appear in committed snapshots, participate in persistence helpers, or drive subscriptions by themselves.
+- Private fields are not top-level state properties. They do not create signals, appear in committed snapshots, participate in persistence helpers, or drive subscriptions by themselves. Computeds and queries that read private fields update when their signal-backed state dependencies change; private-only changes do not invalidate those reads.
 - Protected consumer views expose immutable state and callable actions.
 - Published draftable public state is deep-frozen by default. `setAutoFreeze(false)` disables that behavior globally.
 - Computeds and queries read committed state, including when called inside actions.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "preact-sigma",
-  "version": "6.0.1",
+  "version": "6.0.2",
   "keywords": [],
   "license": "MIT",
   "author": "Alec Larson",