@sladg/apex-state 3.1.0 → 3.2.0

package/dist/testing/index.js

@@ -0,0 +1,1384 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/testing/index.ts
+import React from "react";
+import { act } from "@testing-library/react";
+import { proxy as proxy2, snapshot as snapshot4, useSnapshot as useSnapshot2 } from "valtio";
+
+// src/utils/is.ts
+var isNil = (value) => value == null;
+var isUndefined = (value) => value === void 0;
+var isNull = (value) => value === null;
+var isObject = (value) => {
+  if (value == null || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+};
+var isArray = (value) => Array.isArray(value);
+var isString = (value) => typeof value === "string";
+var isNumber = (value) => typeof value === "number";
+var isBoolean = (value) => typeof value === "boolean";
+var isFunction = (value) => typeof value === "function";
+var isSymbol = (value) => typeof value === "symbol";
+var isDate = (value) => value instanceof Date;
+var isRegExp = (value) => value instanceof RegExp;
+var isPrimitive = (value) => {
+  const type = typeof value;
+  return type === "string" || type === "number" || type === "boolean" || type === "symbol" || type === "bigint" || value == null;
+};
+var isEmptyObject = (value) => {
+  for (const key in value) {
+    if (Object.prototype.hasOwnProperty.call(value, key)) {
+      return false;
+    }
+  }
+  return true;
+};
+var isEmpty = (value) => {
+  if (isNil(value)) return true;
+  if (isNumber(value) || isBoolean(value)) return false;
+  if (isString(value)) return value.length === 0;
+  if (isArray(value)) return value.length === 0;
+  if (isObject(value)) return isEmptyObject(value);
+  return false;
+};
+var isEqualArray = (a, b) => {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (!iEqual(a[i], b[i])) return false;
+  }
+  return true;
+};
+var isEqualObject = (a, b) => {
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  for (const key of keysA) {
+    if (!Object.prototype.hasOwnProperty.call(b, key)) return false;
+    if (!iEqual(a[key], b[key])) return false;
+  }
+  return true;
+};
+var iEqual = (a, b) => {
+  if (a === b) return true;
+  if (isArray(a) && isArray(b)) {
+    return isEqualArray(a, b);
+  }
+  if (isDate(a) && isDate(b)) {
+    return a.getTime() === b.getTime();
+  }
+  if (isRegExp(a) && isRegExp(b)) {
+    return a.toString() === b.toString();
+  }
+  if (isObject(a) && isObject(b)) {
+    return isEqualObject(a, b);
+  }
+  return false;
+};
+var isNotNil = (value) => value != null;
+var isNotUndefined = (value) => value !== void 0;
+var isNotNull = (value) => value !== null;
+var isNotObject = (value) => !isObject(value);
+var isNotArray = (value) => !Array.isArray(value);
+var isNotString = (value) => typeof value !== "string";
+var isNotNumber = (value) => typeof value !== "number";
+var isNotBoolean = (value) => typeof value !== "boolean";
+var isNotFunction = (value) => typeof value !== "function";
+var isNotSymbol = (value) => typeof value !== "symbol";
+var isNotDate = (value) => !(value instanceof Date);
+var isNotRegExp = (value) => !(value instanceof RegExp);
+var isNotPrimitive = (value) => {
+  const type = typeof value;
+  return !(type === "string" || type === "number" || type === "boolean" || type === "symbol" || type === "bigint" || value == null);
+};
+var isNotEmpty = (value) => !isEmpty(value);
+var isNotEqual = (a, b) => !iEqual(a, b);
+var is = {
+  nil: isNil,
+  undefined: isUndefined,
+  null: isNull,
+  object: isObject,
+  array: isArray,
+  string: isString,
+  number: isNumber,
+  boolean: isBoolean,
+  function: isFunction,
+  symbol: isSymbol,
+  date: isDate,
+  regexp: isRegExp,
+  primitive: isPrimitive,
+  empty: isEmpty,
+  equal: iEqual,
+  not: {
+    nil: isNotNil,
+    undefined: isNotUndefined,
+    null: isNotNull,
+    object: isNotObject,
+    array: isNotArray,
+    string: isNotString,
+    number: isNotNumber,
+    boolean: isNotBoolean,
+    function: isNotFunction,
+    symbol: isNotSymbol,
+    date: isNotDate,
+    regexp: isNotRegExp,
+    primitive: isNotPrimitive,
+    empty: isNotEmpty,
+    equal: isNotEqual
+  }
+};
+
+// src/utils/dot.ts
+var pathCache = /* @__PURE__ */ new Map();
+var MAX_CACHE_SIZE = 1e3;
+var getPathParts = (path) => {
+  if (typeof path !== "string") {
+    throw new TypeError(
+      `[apex-state] Path must be a string, received ${typeof path}: ${JSON.stringify(path)}. Paths must be dot-notation strings like "user.email" or "items.0.name".`
+    );
+  }
+  let parts = pathCache.get(path);
+  if (!parts) {
+    parts = path.split(".");
+    if (pathCache.size >= MAX_CACHE_SIZE) {
+      pathCache.clear();
+    }
+    pathCache.set(path, parts);
+  }
+  return parts;
+};
+var get = (obj, path) => {
+  const parts = getPathParts(path);
+  let current = obj;
+  for (const part of parts) {
+    if (is.not.object(current)) {
+      return void 0;
+    }
+    current = Reflect.get(current, part);
+  }
+  return current;
+};
+var get__unsafe = (obj, path) => {
+  const parts = getPathParts(path);
+  let current = obj;
+  for (const part of parts) {
+    if (is.not.object(current)) {
+      return void 0;
+    }
+    current = Reflect.get(current, part);
+  }
+  return current;
+};
+var set = (obj, path, value) => {
+  const keys = getPathParts(path);
+  const last = keys.length - 1;
+  let current = obj;
+  for (let i = 0; i < last; i++) {
+    let next = Reflect.get(current, keys[i]);
+    if (!is.object(next)) {
+      next = {};
+      Reflect.set(current, keys[i], next);
+    }
+    current = next;
+  }
+  Reflect.set(current, keys[last], value);
+};
+var set__unsafe = (obj, path, value) => {
+  const keys = getPathParts(path);
+  const last = keys.length - 1;
+  let current = obj;
+  for (let i = 0; i < last; i++) {
+    let next = Reflect.get(current, keys[i]);
+    if (!is.object(next)) {
+      next = {};
+      Reflect.set(current, keys[i], next);
+    }
+    current = next;
+  }
+  Reflect.set(current, keys[last], value);
+};
+var has = (obj, path) => {
+  const parts = getPathParts(path);
+  let current = obj;
+  for (const part of parts) {
+    if (is.not.object(current)) {
+      return false;
+    }
+    current = Reflect.get(current, part);
+  }
+  return is.not.undefined(current);
+};
+var same = (obj, ...paths) => {
+  if (paths.length === 0) return true;
+  if (paths.length === 1) return true;
+  const firstValue = get__unsafe(obj, paths[0]);
+  for (let i = 1; i < paths.length; i++) {
+    if (!is.equal(get__unsafe(obj, paths[i]), firstValue)) {
+      return false;
+    }
+  }
+  return true;
+};
+var dot = {
+  get,
+  get__unsafe,
+  set,
+  set__unsafe,
+  has,
+  same
+};
+
+// src/store/create-store.ts
+import { useCallback, useLayoutEffect } from "react";
+import { snapshot as snapshot3, useSnapshot } from "valtio";
+
+// src/concerns/registration.ts
+import { effect } from "valtio-reactive";
+
+// src/utils/bool-logic.ts
+var evaluateNumericComparison = (logic, state) => {
+  if ("GT" in logic) {
+    const [path, threshold] = logic.GT;
+    const value = dot.get__unsafe(state, path);
+    return is.number(value) && value > threshold;
+  }
+  if ("LT" in logic) {
+    const [path, threshold] = logic.LT;
+    const value = dot.get__unsafe(state, path);
+    return is.number(value) && value < threshold;
+  }
+  if ("GTE" in logic) {
+    const [path, threshold] = logic.GTE;
+    const value = dot.get__unsafe(state, path);
+    return is.number(value) && value >= threshold;
+  }
+  if ("LTE" in logic) {
+    const [path, threshold] = logic.LTE;
+    const value = dot.get__unsafe(state, path);
+    return is.number(value) && value <= threshold;
+  }
+  return void 0;
+};
+var evaluateBoolLogic = (logic, state) => {
+  if ("IS_EQUAL" in logic) {
+    const [path, expected] = logic.IS_EQUAL;
+    return dot.get__unsafe(state, path) === expected;
+  }
+  if ("EXISTS" in logic) {
+    return is.not.nil(dot.get__unsafe(state, logic.EXISTS));
+  }
+  if ("IS_EMPTY" in logic) {
+    return is.empty(dot.get__unsafe(state, logic.IS_EMPTY));
+  }
+  if ("AND" in logic) {
+    return logic.AND.every((subLogic) => evaluateBoolLogic(subLogic, state));
+  }
+  if ("OR" in logic) {
+    return logic.OR.some((subLogic) => evaluateBoolLogic(subLogic, state));
+  }
+  if ("NOT" in logic) {
+    return !evaluateBoolLogic(logic.NOT, state);
+  }
+  const numericResult = evaluateNumericComparison(logic, state);
+  if (is.not.undefined(numericResult)) {
+    return numericResult;
+  }
+  if ("IN" in logic) {
+    const [path, allowed] = logic.IN;
+    return allowed.includes(dot.get__unsafe(state, path));
+  }
+  return false;
+};
+
+// src/concerns/prebuilts/index.ts
+var prebuilts_exports = {};
+__export(prebuilts_exports, {
+  disabledWhen: () => disabledWhen,
+  dynamicLabel: () => dynamicLabel,
+  dynamicPlaceholder: () => dynamicPlaceholder,
+  dynamicTooltip: () => dynamicTooltip,
+  prebuilts: () => prebuilts,
+  prebuiltsNamespace: () => prebuiltsNamespace,
+  readonlyWhen: () => readonlyWhen,
+  validationState: () => validationState,
+  visibleWhen: () => visibleWhen
+});
+
+// src/concerns/prebuilts/disabled-when.ts
+var disabledWhen = {
+  name: "disabledWhen",
+  description: "Boolean logic for disabled state",
+  evaluate: (props) => {
+    return evaluateBoolLogic(props.boolLogic, props.state);
+  }
+};
+
+// src/utils/interpolation.ts
+var extractPlaceholders = (template) => {
+  const regex = /\{\{([^}]+)\}\}/g;
+  const matches = [];
+  let match;
+  while ((match = regex.exec(template)) !== null) {
+    if (match[1]) {
+      matches.push(match[1]);
+    }
+  }
+  return matches;
+};
+var interpolateTemplate = (template, state) => {
+  return template.replace(/\{\{([^}]+)\}\}/g, (match, path) => {
+    const value = dot.get__unsafe(state, path);
+    if (is.string(value)) return value;
+    if (is.number(value)) return String(value);
+    if (is.boolean(value)) return String(value);
+    return match;
+  });
+};
+
+// src/concerns/prebuilts/dynamic-label.ts
+var dynamicLabel = {
+  name: "dynamicLabel",
+  description: "Template string interpolation for labels",
+  evaluate: (props) => {
+    return interpolateTemplate(props.template, props.state);
+  }
+};
+
+// src/concerns/prebuilts/dynamic-placeholder.ts
+var dynamicPlaceholder = {
+  name: "dynamicPlaceholder",
+  description: "Template string interpolation for placeholders",
+  evaluate: (props) => {
+    return interpolateTemplate(props.template, props.state);
+  }
+};
+
+// src/concerns/prebuilts/dynamic-tooltip.ts
+var dynamicTooltip = {
+  name: "dynamicTooltip",
+  description: "Template string interpolation for tooltips",
+  evaluate: (props) => {
+    return interpolateTemplate(props.template, props.state);
+  }
+};
+
+// src/concerns/prebuilts/readonly-when.ts
+var readonlyWhen = {
+  name: "readonlyWhen",
+  description: "Boolean logic for readonly state",
+  evaluate: (props) => {
+    return evaluateBoolLogic(props.boolLogic, props.state);
+  }
+};
+
+// src/concerns/prebuilts/validation-state.ts
+var validationState = {
+  name: "validationState",
+  description: "Schema validation with isError flag and detailed errors",
+  evaluate: (props) => {
+    const valueToValidate = "scope" in props && props.scope ? dot.get__unsafe(props.state, props.scope) : props.value;
+    const result = props.schema.safeParse(valueToValidate);
+    if (result.success) {
+      return {
+        isError: false,
+        errors: []
+      };
+    }
+    const errors = result.error.errors.map((err) => ({
+      field: err.path.length > 0 ? err.path.join(".") : ".",
+      message: err.message
+    }));
+    return {
+      isError: true,
+      errors
+    };
+  }
+};
+
+// src/concerns/prebuilts/visible-when.ts
+var visibleWhen = {
+  name: "visibleWhen",
+  description: "Boolean logic for visibility",
+  evaluate: (props) => {
+    return evaluateBoolLogic(props.boolLogic, props.state);
+  }
+};
+
+// src/concerns/prebuilts/index.ts
+var prebuilts = [
+  validationState,
+  disabledWhen,
+  readonlyWhen,
+  visibleWhen,
+  dynamicTooltip,
+  dynamicLabel,
+  dynamicPlaceholder
+];
+var prebuiltsNamespace = {
+  validationState,
+  disabledWhen,
+  readonlyWhen,
+  visibleWhen,
+  dynamicTooltip,
+  dynamicLabel,
+  dynamicPlaceholder
+};
+
+// src/concerns/registry.ts
+var findConcern = (name, concerns = prebuilts) => {
+  return concerns.find((c) => c.name === name);
+};
+var defaultConcerns = prebuilts;
+
+// src/concerns/registration.wasm-impl.ts
+import { effect as effect2 } from "valtio-reactive";
+
+// src/core/context.ts
+import { createContext, useContext } from "react";
+var StoreContext = createContext(null);
+StoreContext.displayName = "StoreContext";
+
+// src/pipeline/process-changes.ts
+import { snapshot } from "valtio";
+
+// src/pipeline/apply-batch.ts
+var applyBatch = (changes, state) => {
+  for (const [path, value] of changes) {
+    const pathStr = path;
+    const current = dot.get__unsafe(state, pathStr);
+    if (current !== value) {
+      dot.set__unsafe(state, pathStr, value);
+    }
+  }
+};
+
+// src/pipeline/queue.ts
+var queueChange = (props) => {
+  props.queue.push([props.path, props.value, props.meta]);
+};
+
+// src/pipeline/processors/aggregation-writes.ts
+var distributeToSources = (aggregation, targetPath, changePath, value, meta, queue) => {
+  const isExactMatch = changePath === targetPath;
+  for (const sourcePath of aggregation.sourcePaths) {
+    const finalPath = isExactMatch ? sourcePath : `${sourcePath}.${changePath.substring(targetPath.length + 1)}`;
+    queueChange({
+      queue,
+      path: finalPath,
+      value,
+      meta: { ...meta, isAggregationChange: true }
+    });
+  }
+};
+var processAggregationWrites = (changes, store) => {
+  const { aggregations } = store._internal.registrations;
+  const { queue } = store._internal.processing;
+  for (let i = changes.length - 1; i >= 0; i--) {
+    const [path, value, meta] = changes[i];
+    for (const [targetPath, items] of aggregations) {
+      const isExactMatch = path === targetPath;
+      const isChildPath = path.startsWith(targetPath + ".");
+      if (isExactMatch || isChildPath) {
+        for (const aggregation of items) {
+          distributeToSources(aggregation, targetPath, path, value, meta, queue);
+        }
+        changes.splice(i, 1);
+        break;
+      }
+    }
+  }
+};
+
+// src/core/path-groups.ts
+var makeEdgeKey = (path1, path2) => path1 < path2 ? `${path1}--${path2}` : `${path2}--${path1}`;
+var bfsCollect = (adjacency, startPath) => {
+  const visited = /* @__PURE__ */ new Set([startPath]);
+  const queue = [startPath];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    const neighbors = adjacency.get(current);
+    if (!neighbors) continue;
+    for (const neighbor of neighbors) {
+      if (!visited.has(neighbor)) {
+        visited.add(neighbor);
+        queue.push(neighbor);
+      }
+    }
+  }
+  return visited;
+};
+var removeIsolatedPath = (groups, path) => {
+  const groupId = groups.pathToGroup.get(path);
+  if (groupId !== void 0) {
+    groups.groupToPaths.get(groupId)?.delete(path);
+    if (groups.groupToPaths.get(groupId)?.size === 0) {
+      groups.groupToPaths.delete(groupId);
+    }
+  }
+  groups.pathToGroup.delete(path);
+  groups.adjacency.delete(path);
+};
+var handleComponentSplit = (groups, path1, path2) => {
+  const reachableFromPath1 = bfsCollect(groups.adjacency, path1);
+  if (reachableFromPath1.has(path2)) return;
+  const newGroupId = groups.nextGroupId++;
+  const oldGroupId = groups.pathToGroup.get(path2);
+  const newComponent = bfsCollect(groups.adjacency, path2);
+  for (const path of newComponent) {
+    groups.pathToGroup.set(path, newGroupId);
+    groups.groupToPaths.get(oldGroupId)?.delete(path);
+  }
+  groups.groupToPaths.set(newGroupId, newComponent);
+  if (groups.groupToPaths.get(oldGroupId)?.size === 0) {
+    groups.groupToPaths.delete(oldGroupId);
+  }
+};
+var addEdge = (groups, path1, path2) => {
+  const edgeKey = makeEdgeKey(path1, path2);
+  if (groups.edges.has(edgeKey)) return;
+  groups.edges.add(edgeKey);
+  if (!groups.adjacency.has(path1)) groups.adjacency.set(path1, /* @__PURE__ */ new Set());
+  if (!groups.adjacency.has(path2)) groups.adjacency.set(path2, /* @__PURE__ */ new Set());
+  groups.adjacency.get(path1).add(path2);
+  groups.adjacency.get(path2).add(path1);
+  const g1 = groups.pathToGroup.get(path1);
+  const g2 = groups.pathToGroup.get(path2);
+  if (g1 === void 0 && g2 === void 0) {
+    const id = groups.nextGroupId++;
+    groups.pathToGroup.set(path1, id);
+    groups.pathToGroup.set(path2, id);
+    groups.groupToPaths.set(id, /* @__PURE__ */ new Set([path1, path2]));
+  } else if (g1 !== void 0 && g2 === void 0) {
+    groups.pathToGroup.set(path2, g1);
+    groups.groupToPaths.get(g1).add(path2);
+  } else if (g1 === void 0 && g2 !== void 0) {
+    groups.pathToGroup.set(path1, g2);
+    groups.groupToPaths.get(g2).add(path1);
+  } else if (g1 !== g2) {
+    const set1 = groups.groupToPaths.get(g1);
+    const set2 = groups.groupToPaths.get(g2);
+    const [smallerId, smallerSet, largerId, largerSet] = set1.size < set2.size ? [g1, set1, g2, set2] : [g2, set2, g1, set1];
+    for (const path of smallerSet) {
+      groups.pathToGroup.set(path, largerId);
+      largerSet.add(path);
+    }
+    groups.groupToPaths.delete(smallerId);
+  } else {
+  }
+};
+var removeEdge = (groups, path1, path2) => {
+  const edgeKey = makeEdgeKey(path1, path2);
+  if (!groups.edges.has(edgeKey)) return;
+  groups.edges.delete(edgeKey);
+  groups.adjacency.get(path1)?.delete(path2);
+  groups.adjacency.get(path2)?.delete(path1);
+  const adj1 = groups.adjacency.get(path1);
+  const adj2 = groups.adjacency.get(path2);
+  const path1Isolated = !adj1 || adj1.size === 0;
+  const path2Isolated = !adj2 || adj2.size === 0;
+  if (path1Isolated) removeIsolatedPath(groups, path1);
+  if (path2Isolated) removeIsolatedPath(groups, path2);
+  if (!path1Isolated && !path2Isolated) {
+    handleComponentSplit(groups, path1, path2);
+  }
+};
+var getAllGroups = (groups) => [...groups.groupToPaths.values()].map((set2) => [...set2]);
+var getGroupPaths = (groups, path) => {
+  const groupId = groups.pathToGroup.get(path);
+  if (groupId === void 0) return [];
+  return [...groups.groupToPaths.get(groupId)];
+};
+var hasPath = (groups, path) => groups.pathToGroup.has(path);
+var hasEdge = (groups, path1, path2) => groups.edges.has(makeEdgeKey(path1, path2));
+var getPathDegree = (groups, path) => groups.adjacency.get(path)?.size ?? 0;
+
+// src/pipeline/normalize-changes.ts
+var normalizeChange = (props) => {
+  const { changePath, changeValue, changeMeta, registeredPath, matchMode } = props;
+  if (matchMode === "all" && changePath === registeredPath) {
+    return { relativePath: null, value: changeValue, meta: changeMeta };
+  }
+  if (matchMode === "all" && registeredPath.startsWith(changePath + ".")) {
+    if (is.not.object(changeValue)) {
+      return null;
+    }
+    const nestedPath = registeredPath.slice(changePath.length + 1);
+    const extractedValue = dot.get__unsafe(changeValue, nestedPath);
+    if (extractedValue === void 0) {
+      return null;
+    }
+    return { relativePath: null, value: extractedValue, meta: changeMeta };
+  }
+  if (changePath.startsWith(registeredPath + ".")) {
+    const relativePath = changePath.slice(registeredPath.length + 1);
+    return { relativePath, value: changeValue, meta: changeMeta };
+  }
+  return null;
+};
+var normalizeChangesForGroups = (props) => {
+  const result = [];
+  const matchMode = props.matchMode ?? "all";
+  for (const change of props.changes) {
+    const [changePath, changeValue, changeMeta] = change;
+    for (const group of props.pathGroups) {
+      let match = null;
+      for (const registeredPath of group) {
+        const normalized = normalizeChange({
+          changePath,
+          changeValue,
+          changeMeta,
+          registeredPath,
+          matchMode
+        });
+        if (normalized) {
+          match = { path: registeredPath, normalized };
+          break;
+        }
+      }
+      if (match) {
+        result.push({
+          matchedPath: match.path,
+          relativePath: match.normalized.relativePath,
+          value: match.normalized.value,
+          meta: match.normalized.meta,
+          connectedPaths: group
+        });
+      }
+    }
+  }
+  return result;
+};
+
+// src/pipeline/processors/flip-paths.ts
+var processFlipPaths = (changes, store) => {
+  const { flip } = store._internal.graphs;
+  const { queue } = store._internal.processing;
+  const pathGroups = getAllGroups(flip);
+  if (pathGroups.length === 0) return;
+  const normalizedChanges = normalizeChangesForGroups({
+    changes,
+    pathGroups,
+    matchMode: "all"
+  });
+  for (const match of normalizedChanges) {
+    if (typeof match.value !== "boolean") continue;
+    const meta = { isFlipPathChange: true, ...match.meta };
+    for (const neighborPath of match.connectedPaths) {
+      if (neighborPath === match.matchedPath) continue;
+      const targetPath = match.relativePath ? `${neighborPath}.${match.relativePath}` : neighborPath;
+      queueChange({ queue, path: targetPath, value: !match.value, meta });
+    }
+  }
+};
+
+// src/utils/path-utils.ts
+var getPathDepth = (path) => {
+  if (!path) return 0;
+  return path.split(".").length;
+};
+
+// src/pipeline/processors/listeners.ts
+var processListener = (props) => {
+  if (props.relevantChanges.length === 0) return;
+  const scope = props.registration.scope ?? "";
+  const scopedState = scope === "" ? props.currentState : dot.get__unsafe(props.currentState, scope);
+  const result = props.registration.fn(props.relevantChanges, scopedState);
+  if (!result || result.length === 0) return;
+  for (const [path, value, changeMeta] of result) {
+    const meta = { isListenerChange: true, ...changeMeta };
+    queueChange({ queue: props.queue, path, value, meta });
+  }
+};
+var filterAndRelativize = (changes, listenerPath) => {
+  const result = [];
+  if (listenerPath === "") {
+    for (const change of changes) {
+      if (!change[0].includes(".")) {
+        result.push(change);
+      }
+    }
+    return result;
+  }
+  const prefix = listenerPath + ".";
+  for (const change of changes) {
+    if (change[0] === listenerPath) {
+      result.push([change[0], change[1], change[2]]);
+    } else if (change[0].startsWith(prefix)) {
+      result.push([change[0].slice(prefix.length), change[1], change[2]]);
+    } else {
+    }
+  }
+  return result;
+};
+var processListeners = (changes, store, currentState) => {
+  const { listeners, sortedListenerPaths } = store._internal.graphs;
+  const { queue } = store._internal.processing;
+  const effectiveChanges = [];
+  for (const change of changes) {
+    const current = dot.get__unsafe(currentState, change[0]);
+    if (current !== change[1]) {
+      effectiveChanges.push(change);
+    } else {
+    }
+  }
+  if (effectiveChanges.length === 0) return;
+  const sortedChanges = effectiveChanges.sort(
+    (a, b) => getPathDepth(b[0]) - getPathDepth(a[0])
+  );
+  for (const listenerPath of sortedListenerPaths) {
+    const pathListeners = listeners.get(listenerPath);
+    const relevantChanges = filterAndRelativize(sortedChanges, listenerPath);
+    for (const registration of pathListeners) {
+      processListener({
+        // Safe: ListenerRegistration and ListenerRegistrationInternal have same runtime shape
+        // The function signature difference (ArrayOfChanges vs AnyChange[]) is a compile-time distinction only
+        registration,
+        relevantChanges,
+        currentState,
+        queue
+      });
+    }
+  }
+};
+
+// src/pipeline/processors/sync-paths.ts
+var processSyncPaths = (changes, store) => {
+  const { sync } = store._internal.graphs;
+  const { queue } = store._internal.processing;
+  const pathGroups = getAllGroups(sync);
+  if (pathGroups.length === 0) return;
+  const normalizedChanges = normalizeChangesForGroups({
+    changes,
+    pathGroups,
+    matchMode: "all"
+  });
+  for (const match of normalizedChanges) {
+    const meta = { isSyncPathChange: true, ...match.meta };
+    for (const neighborPath of match.connectedPaths) {
+      if (neighborPath === match.matchedPath) continue;
+      const targetPath = match.relativePath ? `${neighborPath}.${match.relativePath}` : neighborPath;
+      queueChange({ queue, path: targetPath, value: match.value, meta });
+    }
+  }
+};
+
+// src/pipeline/process-changes.ts
+var processChangesJS = (store, initialChanges) => {
+  const { processing } = store._internal;
+  const filtered = [];
+  for (const change of initialChanges) {
+    const current = dot.get__unsafe(store.state, change[0]);
+    if (current !== change[1]) {
+      filtered.push(change);
+    }
+  }
+  if (filtered.length === 0) return;
+  processing.queue = [...filtered];
+  const currentState = snapshot(store.state);
+  processAggregationWrites(processing.queue, store);
+  processSyncPaths(processing.queue, store);
+  processFlipPaths(processing.queue, store);
+  const preListenerQueue = [];
+  for (const change of processing.queue) {
+    const current = dot.get__unsafe(store.state, change[0]);
+    if (current !== change[1]) {
+      preListenerQueue.push(change);
+    }
+  }
+  if (preListenerQueue.length === 0) {
+    processing.queue = [];
+    return;
+  }
+  processing.queue = preListenerQueue;
+  processListeners(processing.queue, store, currentState);
+  if (store._debug) {
+    const trackEntry = {
+      input: initialChanges.map(([p, v, m]) => [p, v, m]),
+      applied: processing.queue.map(([path, value]) => ({
+        path,
+        value
+      })),
+      appliedConcerns: [],
+      timestamp: Date.now()
+    };
+    store._debug.calls.push(trackEntry);
+  }
+  applyBatch(processing.queue, store.state);
+};
+var processChangesLegacy = processChangesJS;
+var processChanges = processChangesLegacy;
+
+// src/pipeline/process-changes.wasm-impl.ts
+import { snapshot as snapshot2 } from "valtio";
+var CONCERNS_PREFIX = "_concerns.";
+var CONCERNS_PREFIX_LEN = CONCERNS_PREFIX.length;
+
+// src/sideEffects/prebuilts/aggregation.ts
+import { effect as effect3 } from "valtio-reactive";
+var registerAggregations = (store, id, aggregationPairs) => {
+  const { aggregations } = store._internal.registrations;
+  const disposeCallbacks = [];
+  const targets = /* @__PURE__ */ new Set();
+  const sources = /* @__PURE__ */ new Set();
+  for (const [target, source] of aggregationPairs) {
+    targets.add(target);
+    sources.add(source);
+  }
+  for (const target of targets) {
+    if (sources.has(target)) {
+      throw new Error(
+        `[apex-state] Circular aggregation: "${target}" cannot be both target and source`
+      );
+    }
+  }
+  const byTarget = /* @__PURE__ */ new Map();
+  for (const [target, source] of aggregationPairs) {
+    const existing = byTarget.get(target) ?? [];
+    existing.push(source);
+    byTarget.set(target, existing);
+  }
+  const createdAggregations = [];
+  for (const [targetPath, sourcePaths] of byTarget) {
+    const aggregation = {
+      targetPath,
+      sourcePaths,
+      id: `${id}:${targetPath}`
+      // Optional: for debugging
+    };
+    const existing = aggregations.get(targetPath) ?? [];
+    existing.push(aggregation);
+    aggregations.set(targetPath, existing);
+    createdAggregations.push(aggregation);
+    const dispose = effect3(() => {
+      if (sourcePaths.length === 0) {
+        dot.set__unsafe(store.state, targetPath, null);
+        return;
+      }
+      const allEqual = dot.same(store.state, ...sourcePaths);
+      const result = allEqual ? dot.get__unsafe(store.state, sourcePaths[0]) : void 0;
+      dot.set__unsafe(store.state, targetPath, result);
+    });
+    disposeCallbacks.push(dispose);
+  }
+  return () => {
+    disposeCallbacks.forEach((dispose) => dispose());
+    for (const aggregation of createdAggregations) {
+      const items = aggregations.get(aggregation.targetPath) ?? [];
+      const filtered = items.filter((item) => item !== aggregation);
+      if (filtered.length === 0) {
+        aggregations.delete(aggregation.targetPath);
+      } else {
+        aggregations.set(aggregation.targetPath, filtered);
+      }
+    }
+  };
+};
+
+// src/sideEffects/prebuilts/flip.ts
+var registerFlipPair = (store, path1, path2) => {
+  const { flip } = store._internal.graphs;
+  addEdge(flip, path1, path2);
+  return () => {
+    if (hasEdge(flip, path1, path2)) {
+      removeEdge(flip, path1, path2);
+    }
+    if (hasPath(flip, path1) && getPathDegree(flip, path1) === 0) {
+      removeEdge(flip, path1, path1);
+    }
+    if (hasPath(flip, path2) && getPathDegree(flip, path2) === 0) {
+      removeEdge(flip, path2, path2);
+    }
+  };
+};
+
+// src/sideEffects/prebuilts/listeners.ts
+var nextSubscriberId = 0;
+var updateSortedListenerPaths = (graphs) => {
+  graphs.sortedListenerPaths = Array.from(graphs.listeners.keys()).sort(
+    (a, b) => getPathDepth(b) - getPathDepth(a)
+  );
+};
+var validateScopeAndPath = (path, scope) => {
+  if (path === null || scope === null) return;
+  if (path === scope) return;
+  if (!path.startsWith(scope + ".")) {
+    throw new Error(
+      `Invalid listener: scope '${scope}' must be a parent/ancestor of path '${path}', or one must be null`
+    );
+  }
+};
+var registerListenerLegacy = (store, registration) => {
+  const { graphs } = store._internal;
+  const { listeners, listenerHandlers } = graphs;
+  validateScopeAndPath(registration.path, registration.scope);
+  const subscriberId = nextSubscriberId++;
+  const mapKey = registration.path ?? "";
+  const existing = listeners.get(mapKey) ?? [];
+  const originalFn = registration.fn;
+  registration.fn = (changes, state) => store._internal.timing.run("listeners", () => originalFn(changes, state), {
+    path: mapKey,
+    name: "listener"
+  });
+  listeners.set(mapKey, [...existing, registration]);
+  listenerHandlers.set(subscriberId, {
+    scope: registration.scope,
+    fn: registration.fn
+  });
+  updateSortedListenerPaths(graphs);
+  return () => {
+    const list = listeners.get(mapKey);
+    if (list) {
+      const filtered = list.filter((l) => l !== registration);
+      if (filtered.length > 0) {
+        listeners.set(mapKey, filtered);
+      } else {
+        listeners.delete(mapKey);
+      }
+      updateSortedListenerPaths(graphs);
+    }
+    listenerHandlers.delete(subscriberId);
+  };
+};
+
+// src/sideEffects/prebuilts/sync.ts
+var collectGroupSyncChanges = (store, component) => {
+  const valueCounts = /* @__PURE__ */ new Map();
+  for (const path of component) {
+    const value = dot.get__unsafe(store.state, path);
+    if (is.not.nil(value)) {
+      const count = valueCounts.get(value) ?? 0;
+      valueCounts.set(value, count + 1);
+    }
+  }
+  let mostCommonValue = void 0;
+  let maxCount = 0;
+  for (const [value, count] of valueCounts) {
+    if (count > maxCount) {
+      maxCount = count;
+      mostCommonValue = value;
+    }
+  }
+  const changes = [];
+  if (is.not.undefined(mostCommonValue)) {
+    for (const path of component) {
+      const currentValue = dot.get__unsafe(store.state, path);
+      if (currentValue !== mostCommonValue) {
+        changes.push([
+          path,
+          mostCommonValue,
+          { isSyncPathChange: true }
+        ]);
+      }
+    }
+  }
+  return changes;
+};
+var makeSyncEdgeCleanup = (sync, path1, path2) => () => {
+  if (hasEdge(sync, path1, path2)) {
+    removeEdge(sync, path1, path2);
+  }
+  if (hasPath(sync, path1) && getPathDegree(sync, path1) === 0) {
+    removeEdge(sync, path1, path1);
+  }
+  if (hasPath(sync, path2) && getPathDegree(sync, path2) === 0) {
+    removeEdge(sync, path2, path2);
+  }
+};
+var registerSyncPairsBatch = (store, pairs) => {
+  const { sync } = store._internal.graphs;
+  const edgeCleanups = [];
+  for (const [path1, path2] of pairs) {
+    addEdge(sync, path1, path2);
+    edgeCleanups.push(makeSyncEdgeCleanup(sync, path1, path2));
+  }
+  const processedGroups = /* @__PURE__ */ new Set();
+  const allChanges = [];
+  for (const [path1] of pairs) {
+    const groupId = sync.pathToGroup.get(path1);
+    if (groupId === void 0 || processedGroups.has(groupId)) continue;
+    processedGroups.add(groupId);
+    const component = getGroupPaths(sync, path1);
+    const changes = collectGroupSyncChanges(store, component);
+    allChanges.push(...changes);
+  }
+  if (allChanges.length > 0) {
+    processChanges(store, allChanges);
+  }
+  return () => edgeCleanups.forEach((fn) => fn());
+};
+
+// src/sideEffects/registration.ts
+var registerSideEffectsImpl = (store, id, effects) => {
+  const cleanups = [];
+  if (effects.syncPaths) {
+    const cleanup = registerSyncPairsBatch(store, effects.syncPaths);
+    cleanups.push(cleanup);
+  }
+  if (effects.flipPaths) {
+    for (const [path1, path2] of effects.flipPaths) {
+      const cleanup = registerFlipPair(store, path1, path2);
+      cleanups.push(cleanup);
+    }
+  }
+  if (effects.aggregations) {
+    const cleanup = registerAggregations(store, id, effects.aggregations);
+    cleanups.push(cleanup);
+  }
+  if (effects.listeners) {
+    for (const listener of effects.listeners) {
+      const cleanup = registerListenerLegacy(store, listener);
+      cleanups.push(cleanup);
+    }
+  }
+  const combinedCleanup = () => cleanups.forEach((fn) => fn());
+  store._internal.registrations.sideEffectCleanups.set(id, combinedCleanup);
+  return () => {
+    combinedCleanup();
+    store._internal.registrations.sideEffectCleanups.delete(id);
+  };
+};
+var registerSideEffects = (store, id, effects) => store._internal.timing.run(
+  "registration",
+  () => registerSideEffectsImpl(store, id, effects),
+  { path: id, name: "sideEffects" }
+);
+
+// src/utils/json.ts
+var createFastJson = (placeholders = []) => {
+  const encodeMap = /* @__PURE__ */ new Map();
+  const decodeMap = /* @__PURE__ */ new Map();
+  for (const p of placeholders) {
+    encodeMap.set(p.value, p.encoded);
+    decodeMap.set(p.encoded, p.value);
+  }
+  const stringify = (value) => {
+    if (encodeMap.has(value)) return encodeMap.get(value);
+    if (typeof value === "number" || typeof value === "boolean")
+      return String(value);
+    if (value === null) return "null";
+    return JSON.stringify(value);
+  };
+  const parse = (json) => {
+    if (decodeMap.has(json)) return decodeMap.get(json);
+    const c = json.charCodeAt(0);
+    if (c >= 48 && c <= 57 || c === 45) return Number(json);
+    if (json === "true") return true;
+    if (json === "false") return false;
+    if (json === "null") return null;
+    return JSON.parse(json);
+  };
+  return { stringify, parse };
+};
+
+// src/wasm/bridge.ts
+var UNDEFINED_SENTINEL_JSON = '"__APEX_UNDEFINED__"';
+var { stringify: fastStringify, parse: fastParse } = createFastJson([
+  { value: void 0, encoded: UNDEFINED_SENTINEL_JSON }
+]);
+
+// src/store/provider.tsx
+import { useEffect, useMemo, useState } from "react";
+import { proxy, ref } from "valtio";
+
+// src/utils/derive-values.ts
+import { computed } from "valtio-reactive";
+
+// src/store/provider.tsx
+import { jsx } from "react/jsx-runtime";
+
+// src/hooks/use-buffered-field.ts
+import { useCallback as useCallback2, useState as useState2 } from "react";
+var useBufferedField = (field) => {
+  const { value: storedValue, setValue: setStoredValue } = field;
+  const [localValue, setLocalValue] = useState2(null);
+  const isEditing = localValue !== null;
+  const isDirty = isEditing && localValue !== storedValue;
+  const setValue = useCallback2((newValue) => {
+    setLocalValue(newValue);
+  }, []);
+  const commit = useCallback2(() => {
+    if (localValue !== null) {
+      setStoredValue(localValue);
+    }
+    setLocalValue(null);
+  }, [localValue, setStoredValue]);
+  const cancel = useCallback2(() => {
+    setLocalValue(null);
+  }, []);
+  const value = isEditing ? localValue : storedValue;
+  return { value, setValue, commit, cancel, isDirty };
+};
+
+// src/hooks/use-keyboard-select.ts
+import { useCallback as useCallback3, useRef } from "react";
+var useKeyboardSelect = (field, config) => {
+  const { setValue } = field;
+  const { options, debounceMs = 500, matchFromStart = true } = config;
+  const searchRef = useRef("");
+  const timeoutRef = useRef(null);
+  const onKeyDown = useCallback3(
+    (e) => {
+      if (e.key.length !== 1) return;
+      if (e.ctrlKey || e.metaKey || e.altKey) return;
+      const char = e.key.toLowerCase();
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+      searchRef.current += char;
+      const search = searchRef.current;
+      const match = options.find((opt) => {
+        const label = opt.label.toLowerCase();
+        return matchFromStart ? label.startsWith(search) : label.includes(search);
+      });
+      if (match) {
+        setValue(match.value);
+      }
+      timeoutRef.current = setTimeout(() => {
+        searchRef.current = "";
+      }, debounceMs);
+    },
+    [options, setValue, debounceMs, matchFromStart]
+  );
+  return { ...field, onKeyDown };
+};
+
+// src/hooks/use-throttled-field.ts
+import { useCallback as useCallback4, useEffect as useEffect2, useRef as useRef2 } from "react";
+var useThrottledField = (field, config) => {
+  const { setValue: originalSetValue, ...rest } = field;
+  const { ms } = config;
+  const throttleRef = useRef2({
+    timeoutId: null,
+    lastFlushTime: 0,
+    pendingValue: void 0,
+    pendingArgs: void 0,
+    hasPending: false
+  });
+  const setValue = useCallback4(
+    (newValue, ...args) => {
+      const now = Date.now();
+      const ref2 = throttleRef.current;
+      const timeSinceLastFlush = now - ref2.lastFlushTime;
+      if (timeSinceLastFlush >= ms) {
+        ref2.lastFlushTime = now;
+        originalSetValue(newValue, ...args);
+        return;
+      }
+      ref2.pendingValue = newValue;
+      ref2.pendingArgs = args;
+      ref2.hasPending = true;
+      if (!ref2.timeoutId) {
+        const remainingTime = ms - timeSinceLastFlush;
+        ref2.timeoutId = setTimeout(() => {
+          ref2.timeoutId = null;
+          ref2.lastFlushTime = Date.now();
+          if (ref2.hasPending) {
+            originalSetValue(
+              ref2.pendingValue,
+              ...ref2.pendingArgs
+            );
+            ref2.hasPending = false;
+            ref2.pendingValue = void 0;
+            ref2.pendingArgs = void 0;
+          }
+        }, remainingTime);
+      }
+    },
+    [originalSetValue, ms]
+  );
+  useEffect2(() => {
+    return () => {
+      if (throttleRef.current.timeoutId) {
+        clearTimeout(throttleRef.current.timeoutId);
+      }
+    };
+  }, []);
+  return { ...rest, setValue };
+};
+
+// src/hooks/use-transformed-field.ts
+import { useCallback as useCallback5, useMemo as useMemo2 } from "react";
+var useTransformedField = (field, config) => {
+  const { value: storedValue, setValue: setStoredValue, ...rest } = field;
+  const { to, from } = config;
+  const value = useMemo2(() => to(storedValue), [storedValue, to]);
+  const setValue = useCallback5(
+    (displayValue) => {
+      const storedVal = from(displayValue);
+      setStoredValue(storedVal);
+    },
+    [from, setStoredValue]
+  );
+  return { ...rest, value, setValue };
+};
+
+// src/utils/hash-key.ts
+var _ = (id) => id;
+var rejectDynamic = (path) => {
+  const parts = path.split(".");
+  for (const part of parts) {
+    if (part === "[*]") {
+      throw new Error(
+        `Path contains [*] hash key which is not allowed in store operations. Use concrete paths only.`
+      );
+    }
+  }
+};
+var hashKey = {
+  /** Reject paths with dynamic hash keys */
+  rejectDynamic,
+  /** Alias for _ function */
+  _
+};
+
+// src/utils/apply-changes.ts
+var applyChangesToObject = (obj, changes) => {
+  const result = structuredClone(obj);
+  for (const [path, value] of changes) {
+    dot.set__unsafe(result, path, value);
+  }
+  return result;
+};
+
+// src/testing/index.ts
+var __state = proxy2({
+  /** Current store state (reactive valtio proxy) */
+  value: {},
+  /** Log of all setValue / setChanges calls */
+  calls: [],
+  /** Log of all useConcerns / useSideEffects registrations */
+  effects: []
+});
+var __flush = async () => {
+  await act(async () => {
+  });
+};
+var __reset = () => {
+  const keys = Object.keys(__state.value);
+  keys.forEach((key) => {
+    Reflect.deleteProperty(__state.value, key);
+  });
+  __state.calls.length = 0;
+  __state.effects.length = 0;
+};
+var __typedMock = () => {
+  const api = {
+    set: (path, value) => {
+      dot.set__unsafe(__state.value, path, value);
+      return api;
+    },
+    state: __state,
+    getState: () => snapshot4(__state.value),
+    flush: __flush,
+    reset: __reset
+  };
+  return api;
+};
+var __mocked = {
+  /** Reactive proxy — access .value, .calls, .effects for assertions */
+  state: __state,
+  /**
+   * Seed mock state and return typed chainable.
+   * - `set<T>()` — establish type, no seeding
+   * - `set<T>(data)` — merge data into state, establish type
+   * Subsequent `.set(path, value)` calls are type-safe against T.
+   */
+  set: (data) => {
+    if (data) {
+      Object.assign(__state.value, data);
+    }
+    return __typedMock();
+  },
+  /** Get an immutable snapshot of the current state */
+  getState: () => snapshot4(__state.value),
+  /** Flush pending valtio-triggered React renders */
+  flush: __flush,
+  /** Reset all mock state between tests */
+  reset: __reset
+};
+var createGenericStore2 = (_config) => {
+  const Provider = ({
+    initialState,
+    children
+  }) => {
+    if (initialState && typeof initialState === "object") {
+      Object.assign(__state.value, initialState);
+    }
+    return React.createElement(React.Fragment, null, children);
+  };
+  Provider.displayName = "MockStoreProvider";
+  const useStore = (path) => {
+    const snap = useSnapshot2(__state);
+    const value = dot.get__unsafe(snap.value, path);
+    const setValue = (newValue, meta) => {
+      __state.calls.push({ path, value: newValue, meta });
+      dot.set__unsafe(__state.value, path, newValue);
+    };
+    return [value, setValue];
+  };
+  const useFieldStore = (path) => {
+    const [value, setValue] = useStore(path);
+    return { value, setValue };
+  };
+  const useJitStore = () => {
+    const snap = useSnapshot2(__state);
+    return {
+      proxyValue: snap.value,
+      setChanges: (changes) => {
+        for (const [path, value, meta] of changes) {
+          __state.calls.push({ path, value, meta });
+          dot.set__unsafe(__state.value, path, value);
+        }
+      },
+      getState: () => snapshot4(__state.value)
+    };
+  };
+  const useSideEffects = (id, effects) => {
+    __state.effects.push({ id, type: "sideEffects", registration: effects });
+  };
+  const useConcerns = (id, registration) => {
+    __state.effects.push({ id, type: "concerns", registration });
+  };
+  const withConcerns = () => ({
+    useFieldStore
+  });
+  const api = {
+    Provider,
+    useStore,
+    useFieldStore,
+    useJitStore,
+    useSideEffects,
+    useConcerns,
+    withConcerns
+  };
+  return api;
+};
+export {
+  _,
+  __mocked,
+  applyChangesToObject,
+  createGenericStore2 as createGenericStore,
+  defaultConcerns,
+  dot,
+  evaluateBoolLogic,
+  extractPlaceholders,
+  findConcern,
+  hashKey,
+  interpolateTemplate,
+  is,
+  prebuilts_exports as prebuilts,
+  registerFlipPair,
+  registerListenerLegacy,
+  registerSideEffects,
+  registerSyncPairsBatch,
+  useBufferedField,
+  useKeyboardSelect,
+  useThrottledField,
+  useTransformedField
+};
+//# sourceMappingURL=index.js.map