@sladg/apex-state 3.3.0 → 3.4.1

package/dist/chunk-SLJZLVMQ.js

@@ -0,0 +1,2390 @@
+import {
+  __export
+} from "./chunk-VR6T6OJS.js";
+
+// src/store/create-store.ts
+import { useCallback, useLayoutEffect as useLayoutEffect2 } from "react";
+import { snapshot as snapshot3, useSnapshot } from "valtio";
+
+// src/concerns/registration.ts
+import { effect } from "valtio-reactive";
+
+// 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/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.ts
+var registerConcernEffectsImpl = (store, registration, concerns) => {
+  const disposeCallbacks = [];
+  const resultCache = /* @__PURE__ */ new Map();
+  const concernRefs = /* @__PURE__ */ new Map();
+  Object.keys(registration).forEach((path) => {
+    if (!store._concerns[path]) {
+      store._concerns[path] = {};
+    }
+    concernRefs.set(path, store._concerns[path]);
+  });
+  Object.entries(registration).forEach(([path, concernConfigs]) => {
+    if (!concernConfigs) return;
+    const concernsAtPath = concernRefs.get(path);
+    Object.entries(concernConfigs).forEach(([concernName, config]) => {
+      if (!config) return;
+      let concern = findConcern(concernName, concerns);
+      if (!concern) {
+        if ("evaluate" in config && typeof config.evaluate === "function") {
+          concern = {
+            name: concernName,
+            description: `Custom concern: ${concernName}`,
+            evaluate: config.evaluate
+          };
+        } else if ("boolLogic" in config && config.boolLogic) {
+          concern = {
+            name: concernName,
+            description: `Ad-hoc BoolLogic concern: ${concernName}`,
+            evaluate: (props) => evaluateBoolLogic(props.boolLogic, props.state)
+          };
+        } else {
+          console.warn(`Concern "${concernName}" not found`);
+          return;
+        }
+      }
+      const cacheKey = `${path}.${concernName}`;
+      const dispose = effect(() => {
+        const value = dot.get__unsafe(store.state, path);
+        const evalProps = Object.assign({ state: store.state, path, value }, config);
+        const evaluateFn = "evaluate" in config && typeof config.evaluate === "function" ? config.evaluate : concern.evaluate;
+        const result = store._internal.timing.run(
+          "concerns",
+          () => evaluateFn(evalProps),
+          { path, name: concernName }
+        );
+        const prev = resultCache.get(cacheKey);
+        if (prev !== result) {
+          resultCache.set(cacheKey, result);
+          concernsAtPath[concernName] = result;
+        }
+      });
+      disposeCallbacks.push(dispose);
+    });
+  });
+  return () => {
+    disposeCallbacks.forEach((dispose) => dispose());
+    resultCache.clear();
+    concernRefs.clear();
+    Object.keys(registration).forEach((path) => {
+      const concernConfigs = registration[path];
+      if (!concernConfigs) return;
+      Object.keys(concernConfigs).forEach((concernName) => {
+        if (store._concerns[path]) {
+          Reflect.deleteProperty(store._concerns[path], concernName);
+        }
+      });
+      if (store._concerns[path] && Object.keys(store._concerns[path]).length === 0) {
+        Reflect.deleteProperty(store._concerns, path);
+      }
+    });
+  };
+};
+var registerConcernEffects = (store, registration, concerns) => store._internal.timing.run(
+  "registration",
+  () => registerConcernEffectsImpl(store, registration, concerns),
+  { path: Object.keys(registration).join(","), name: "concerns" }
+);
+
+// src/concerns/registration.wasm-impl.ts
+import { effect as effect2 } from "valtio-reactive";
+var isBoolLogicConfig = (config) => "boolLogic" in config && config["boolLogic"] != null;
+var isValueLogicConfig = (config) => "valueLogic" in config && config["valueLogic"] != null;
+var isSchemaValidation = (concernName, config) => concernName === "validationState" && "schema" in config && !("evaluate" in config);
+var nextValidatorId = 0;
+var nextRegistrationId = 0;
+var registerWasmBatch = (pipeline, boolLogics, validators, valueLogics, validatorConfigs, concernRefs, disposeCallbacks) => {
+  const registrationId = `concerns-${nextRegistrationId++}`;
+  const result = pipeline.registerConcerns({
+    registration_id: registrationId,
+    ...boolLogics.length > 0 && { bool_logics: boolLogics },
+    ...validators.length > 0 && { validators },
+    ...valueLogics.length > 0 && { value_logics: valueLogics }
+  });
+  for (const change of result.bool_logic_changes) {
+    const lastDot = change.path.lastIndexOf(".");
+    const basePath = change.path.slice(0, lastDot);
+    const concernName = change.path.slice(lastDot + 1);
+    const concernsAtPath = concernRefs.get(basePath);
+    if (concernsAtPath && concernName) {
+      concernsAtPath[concernName] = change.value;
+    }
+  }
+  for (const change of result.value_logic_changes) {
+    const lastDot = change.path.lastIndexOf(".");
+    const basePath = change.path.slice(0, lastDot);
+    const concernName = change.path.slice(lastDot + 1);
+    const concernsAtPath = concernRefs.get(basePath);
+    if (concernsAtPath && concernName) {
+      concernsAtPath[concernName] = change.value;
+    }
+  }
+  disposeCallbacks.push(() => {
+    pipeline.unregisterConcerns(registrationId);
+  });
+  validatorConfigs.forEach((config, validatorId) => {
+    const parseResult = config.schema.safeParse(config.initialValue);
+    const validationResult = {
+      isError: !parseResult.success,
+      errors: parseResult.success ? [] : parseResult.error.errors.map((e) => ({
+        field: e.path.length > 0 ? e.path.join(".") : ".",
+        message: e.message
+      }))
+    };
+    config.concernsAtPath[config.concernName] = validationResult;
+    pipeline.validatorSchemas.set(validatorId, config.schema);
+  });
+};
+var createConcernEffect = (store, item, resultCache) => {
+  const { path, concernName, config, concern, concernsAtPath } = item;
+  const cacheKey = `${path}.${concernName}`;
+  const evaluateFn = "evaluate" in config && typeof config["evaluate"] === "function" ? config["evaluate"] : concern.evaluate;
+  return effect2(() => {
+    const value = dot.get__unsafe(store.state, path);
+    const evalProps = Object.assign({ state: store.state, path, value }, config);
+    const result = store._internal.timing.run(
+      "concerns",
+      () => evaluateFn(evalProps),
+      { path, name: concernName }
+    );
+    const prev = resultCache.get(cacheKey);
+    if (prev !== result) {
+      resultCache.set(cacheKey, result);
+      concernsAtPath[concernName] = result;
+    }
+  });
+};
+var isAdHocConcern = (config) => "evaluate" in config && typeof config["evaluate"] === "function";
+var collectValidator = (store, path, concernName, config, concernsAtPath, validators, validatorConfigs) => {
+  const validatorId = nextValidatorId++;
+  const depPaths = "scope" in config && config["scope"] ? [config["scope"]] : [path];
+  validators.push({
+    validator_id: validatorId,
+    output_path: `_concerns.${path}.${concernName}`,
+    dependency_paths: depPaths,
+    scope: ""
+  });
+  const primaryValue = dot.get__unsafe(store.state, depPaths[0]);
+  validatorConfigs.set(validatorId, {
+    schema: config["schema"],
+    initialValue: primaryValue,
+    concernName,
+    concernsAtPath
+  });
+};
+var classifyConcern = (store, path, concernName, config, concernsAtPath, concernMap, result) => {
+  if (isBoolLogicConfig(config)) {
+    result.boolLogics.push({
+      output_path: `${path}.${concernName}`,
+      tree_json: JSON.stringify(config.boolLogic)
+    });
+    return;
+  }
+  if (isValueLogicConfig(config)) {
+    result.valueLogics.push({
+      output_path: `${path}.${concernName}`,
+      tree_json: JSON.stringify(config.valueLogic)
+    });
+    return;
+  }
+  if (isSchemaValidation(concernName, config)) {
+    collectValidator(
+      store,
+      path,
+      concernName,
+      config,
+      concernsAtPath,
+      result.validators,
+      result.validatorConfigs
+    );
+    return;
+  }
+  const concern = concernMap.get(concernName) ?? (isAdHocConcern(config) ? {
+    name: concernName,
+    description: `Custom concern: ${concernName}`,
+    evaluate: config.evaluate
+  } : void 0);
+  if (!concern) {
+    console.warn(`Concern "${concernName}" not found`);
+    return;
+  }
+  result.jsEffects.push({ path, concernName, config, concern, concernsAtPath });
+};
+var collectRegistrations = (store, registrationEntries, concernRefs, concernMap) => {
+  const result = {
+    boolLogics: [],
+    validators: [],
+    valueLogics: [],
+    validatorConfigs: /* @__PURE__ */ new Map(),
+    jsEffects: []
+  };
+  for (const [path, concernConfigs] of registrationEntries) {
+    if (!concernConfigs) continue;
+    const concernsAtPath = concernRefs.get(path);
+    for (const [concernName, config] of Object.entries(concernConfigs)) {
+      if (!config) continue;
+      classifyConcern(
+        store,
+        path,
+        concernName,
+        config,
+        concernsAtPath,
+        concernMap,
+        result
+      );
+    }
+  }
+  return result;
+};
+var cleanupConcerns = (store, registrationEntries) => {
+  for (const [path, concernConfigs] of registrationEntries) {
+    if (!concernConfigs) continue;
+    const concernsObj = store._concerns[path];
+    if (!concernsObj) continue;
+    for (const concernName of Object.keys(concernConfigs)) {
+      Reflect.deleteProperty(concernsObj, concernName);
+    }
+    if (Object.keys(concernsObj).length === 0) {
+      Reflect.deleteProperty(store._concerns, path);
+    }
+  }
+};
+var registerConcernEffectsImpl2 = (store, registration, concerns) => {
+  const disposeCallbacks = [];
+  const resultCache = /* @__PURE__ */ new Map();
+  const concernRefs = /* @__PURE__ */ new Map();
+  const concernMap = /* @__PURE__ */ new Map();
+  for (const c of concerns) {
+    concernMap.set(c.name, c);
+  }
+  const registrationEntries = Object.entries(registration);
+  for (const [path] of registrationEntries) {
+    if (!store._concerns[path]) {
+      store._concerns[path] = {};
+    }
+    concernRefs.set(path, store._concerns[path]);
+  }
+  const { boolLogics, validators, valueLogics, validatorConfigs, jsEffects } = collectRegistrations(store, registrationEntries, concernRefs, concernMap);
+  if (boolLogics.length > 0 || validators.length > 0 || valueLogics.length > 0) {
+    registerWasmBatch(
+      store._internal.pipeline,
+      boolLogics,
+      validators,
+      valueLogics,
+      validatorConfigs,
+      concernRefs,
+      disposeCallbacks
+    );
+  }
+  for (const item of jsEffects) {
+    disposeCallbacks.push(createConcernEffect(store, item, resultCache));
+  }
+  return () => {
+    for (const dispose of disposeCallbacks) dispose();
+    resultCache.clear();
+    concernRefs.clear();
+    cleanupConcerns(store, registrationEntries);
+  };
+};
+var registerConcernEffects2 = (store, registration, concerns) => store._internal.timing.run(
+  "registration",
+  () => registerConcernEffectsImpl2(store, registration, concerns),
+  { path: Object.keys(registration).join(","), name: "concerns" }
+);
+
+// src/core/context.ts
+import { createContext, useContext } from "react";
+var StoreContext = createContext(null);
+StoreContext.displayName = "StoreContext";
+var useStoreContext = () => {
+  const store = useContext(StoreContext);
+  if (!store) {
+    throw new Error(
+      "useStoreContext must be used within a Store Provider. Make sure your component is wrapped in <store.Provider>."
+    );
+  }
+  return store;
+};
+
+// 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 createPathGroups = (wasmGraphType) => {
+  const groups = {
+    pathToGroup: /* @__PURE__ */ new Map(),
+    groupToPaths: /* @__PURE__ */ new Map(),
+    edges: /* @__PURE__ */ new Set(),
+    adjacency: /* @__PURE__ */ new Map(),
+    nextGroupId: 0
+  };
+  if (wasmGraphType !== void 0) {
+    groups.wasmGraphType = wasmGraphType;
+  }
+  return groups;
+};
+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[0], change[1], change[2] ?? {}]);
+      }
+    }
+    return result;
+  }
+  const prefix = listenerPath + ".";
+  for (const change of changes) {
+    const meta = change[2] ?? {};
+    if (change[0] === listenerPath) {
+      result.push([change[0], change[1], meta]);
+    } else if (change[0].startsWith(prefix)) {
+      result.push([change[0].slice(prefix.length), change[1], meta]);
+    } 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 ORIGIN_TO_META = {
+  sync: "isSyncPathChange",
+  flip: "isFlipPathChange",
+  aggregation: "isAggregationChange",
+  computation: "isComputationChange",
+  clear: "isClearPathChange",
+  listener: "isListenerChange"
+};
+var tuplesToBridgeChanges = (changes) => changes.map(([path, value]) => ({
+  path,
+  value
+}));
+var buildUserMetaByPath = (changes) => {
+  const map = /* @__PURE__ */ new Map();
+  for (const change of changes) {
+    const meta = change[2];
+    if (meta && Object.keys(meta).length > 0) {
+      map.set(change[0], meta);
+    }
+  }
+  return map;
+};
+var bridgeChangesToTuples = (changes, userMetaByPath) => changes.map((c) => {
+  const baseMeta = userMetaByPath?.get(c.path) ?? {};
+  const originKey = c.origin ? ORIGIN_TO_META[c.origin] : void 0;
+  const meta = originKey ? { ...baseMeta, [originKey]: true } : baseMeta;
+  return [c.path, c.value, meta];
+});
+var buildDispatchInput = (d, stateChanges, extra, userMetaByPath) => {
+  const input = [];
+  for (const id of d.input_change_ids) {
+    const change = stateChanges[id];
+    if (change !== void 0) {
+      const baseMeta = userMetaByPath?.get(change.path) ?? {};
+      const originKey = change.origin ? ORIGIN_TO_META[change.origin] : void 0;
+      const meta = originKey ? { ...baseMeta, [originKey]: true } : baseMeta;
+      input.push([change.path, change.value, meta]);
+    }
+  }
+  const extraChanges = extra.get(d.dispatch_id);
+  if (extraChanges) {
+    for (const c of extraChanges) {
+      const baseMeta = userMetaByPath?.get(c.path) ?? {};
+      const originKey = c.origin ? ORIGIN_TO_META[c.origin] : void 0;
+      const meta = originKey ? { ...baseMeta, [originKey]: true } : baseMeta;
+      input.push([c.path, c.value, meta]);
+    }
+  }
+  return input;
+};
+var remapPath = (path, remapPrefix) => {
+  if (!remapPrefix) return path;
+  return path === "" ? remapPrefix : `${remapPrefix}.${path}`;
+};
+var propagateChanges = (dispatchId, producedChanges, propagationMap, extra) => {
+  const targets = propagationMap[dispatchId];
+  if (!targets) return;
+  for (const t of targets) {
+    let existing = extra.get(t.target_dispatch_id);
+    if (!existing) {
+      existing = [];
+      extra.set(t.target_dispatch_id, existing);
+    }
+    for (const c of producedChanges) {
+      existing.push({
+        path: remapPath(c.path, t.remap_prefix),
+        value: c.value,
+        ...c.origin ? { origin: c.origin } : {}
+      });
+    }
+  }
+};
+var executeFullExecutionPlan = (plan, stateChanges, store, userMetaByPath) => {
+  if (!plan || plan.groups.length === 0) {
+    return [];
+  }
+  const { listenerHandlers } = store._internal.graphs;
+  const allProducedChanges = [];
+  const extra = /* @__PURE__ */ new Map();
+  const currentState = snapshot2(store.state);
+  for (const group of plan.groups) {
+    for (const d of group.dispatches) {
+      const registration = listenerHandlers.get(d.subscriber_id);
+      if (!registration) continue;
+      const scope = registration.scope ?? "";
+      const scopedState = scope === "" ? currentState : dot.get__unsafe(currentState, scope);
+      const input = buildDispatchInput(d, stateChanges, extra, userMetaByPath);
+      const result = registration.fn(input, scopedState);
+      if (!result || !result.length) continue;
+      const producedChanges = result.map(
+        ([path, value]) => ({ path, value, origin: "listener" })
+      );
+      allProducedChanges.push(...producedChanges);
+      propagateChanges(
+        d.dispatch_id,
+        producedChanges,
+        plan.propagation_map,
+        extra
+      );
+    }
+  }
+  return allProducedChanges;
+};
+var applyConcernChanges = (changes, concerns) => {
+  for (const c of changes) {
+    const lastDot = c.path.lastIndexOf(".");
+    const basePath = c.path.slice(0, lastDot);
+    const concernName = c.path.slice(lastDot + 1);
+    if (!concerns[basePath]) {
+      concerns[basePath] = {};
+    }
+    concerns[basePath][concernName] = c.value;
+  }
+};
+var runValidators = (validatorsToRun, pipeline) => {
+  const validationResults = [];
+  for (const validator of validatorsToRun) {
+    const schema = pipeline.validatorSchemas.get(validator.validator_id);
+    if (!schema) continue;
+    const entries = validator.dependency_values instanceof Map ? Array.from(validator.dependency_values.entries()) : Object.entries(validator.dependency_values);
+    const values = Object.fromEntries(
+      entries.map(([k, v]) => [k, JSON.parse(v)])
+    );
+    const primaryValue = Object.values(values)[0];
+    const parseResult = schema.safeParse(primaryValue);
+    validationResults.push({
+      path: validator.output_path,
+      // Already has _concerns. prefix
+      value: {
+        isError: !parseResult.success,
+        errors: parseResult.success ? [] : parseResult.error.errors.map((e) => ({
+          field: e.path.length > 0 ? e.path.join(".") : ".",
+          message: e.message
+        }))
+      }
+    });
+  }
+  return validationResults;
+};
+var CONCERNS_PREFIX = "_concerns.";
+var CONCERNS_PREFIX_LEN = CONCERNS_PREFIX.length;
+var partitionChanges = (changes) => {
+  const stateChanges = [];
+  const concernChanges = [];
+  for (const change of changes) {
+    if (change.path.startsWith(CONCERNS_PREFIX)) {
+      concernChanges.push({
+        path: change.path.slice(CONCERNS_PREFIX_LEN),
+        value: change.value,
+        ...change.origin ? { origin: change.origin } : {}
+      });
+    } else {
+      stateChanges.push(change);
+    }
+  }
+  return { stateChanges, concernChanges };
+};
+var pushDebugChanges = (target, changes) => {
+  for (const c of changes) {
+    target.push({ path: c.path, value: c.value });
+  }
+};
+var processChangesWasm = (store, initialChanges) => {
+  const pipeline = store._internal.pipeline;
+  const userMetaByPath = buildUserMetaByPath(initialChanges);
+  const bridgeChanges = tuplesToBridgeChanges(initialChanges);
+  const trackEntry = store._debug ? {
+    input: initialChanges.map(([p, v, m]) => [p, v, m]),
+    applied: [],
+    appliedConcerns: [],
+    timestamp: Date.now()
+  } : null;
+  const { state_changes, execution_plan, validators_to_run, has_work } = pipeline.processChanges(bridgeChanges);
+  if (!has_work) {
+    if (trackEntry) store._debug.calls.push(trackEntry);
+    return;
+  }
+  const early = partitionChanges(state_changes);
+  if (early.stateChanges.length > 0) {
+    applyBatch(
+      bridgeChangesToTuples(early.stateChanges, userMetaByPath),
+      store.state
+    );
+  }
+  const produced = executeFullExecutionPlan(
+    execution_plan,
+    state_changes,
+    store,
+    userMetaByPath
+  );
+  if (early.concernChanges.length > 0) {
+    applyConcernChanges(early.concernChanges, store._concerns);
+  }
+  const validationResults = runValidators(validators_to_run, pipeline);
+  const jsChanges = produced.concat(validationResults);
+  const final = pipeline.pipelineFinalize(jsChanges);
+  const late = partitionChanges(final.state_changes);
+  if (late.stateChanges.length > 0) {
+    applyBatch(
+      bridgeChangesToTuples(late.stateChanges, userMetaByPath),
+      store.state
+    );
+  }
+  if (late.concernChanges.length > 0) {
+    applyConcernChanges(late.concernChanges, store._concerns);
+  }
+  if (trackEntry) {
+    pushDebugChanges(trackEntry.applied, early.stateChanges);
+    pushDebugChanges(trackEntry.applied, late.stateChanges);
+    pushDebugChanges(trackEntry.appliedConcerns, early.concernChanges);
+    pushDebugChanges(trackEntry.appliedConcerns, late.concernChanges);
+    store._debug.calls.push(trackEntry);
+  }
+};
+
+// 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/sideEffects/registration.wasm-impl.ts
+var nextSubscriberId2 = 0;
+var registerSideEffects2 = (store, id, effects) => {
+  const syncPairs = effects.syncPaths ?? [];
+  const flipPairs = effects.flipPaths ?? [];
+  const aggregationPairs = (effects.aggregations ?? []).map(
+    ([target, source, condition]) => condition ? [target, source, JSON.stringify(condition)] : [target, source]
+  );
+  const computationPairs = (effects.computations ?? []).map(
+    ([op, target, source, condition]) => condition ? [
+      op,
+      target,
+      source,
+      JSON.stringify(condition)
+    ] : [op, target, source]
+  );
+  const clearPaths = effects.clearPaths?.map(([triggers, targets, opts]) => ({
+    triggers,
+    targets: opts?.expandMatch ? targets.map((t) => t.replace(/\[\*\]/g, "[**]")) : targets
+  }));
+  const listeners = effects.listeners?.map((listener) => {
+    const { listenerHandlers } = store._internal.graphs;
+    const subscriberId = nextSubscriberId2++;
+    const originalFn = listener.fn;
+    const mapKey = listener.path ?? "";
+    const wrappedFn = (changes, state) => store._internal.timing.run(
+      "listeners",
+      () => originalFn(changes, state),
+      {
+        path: mapKey,
+        name: "listener"
+      }
+    );
+    listenerHandlers.set(subscriberId, {
+      scope: listener.scope,
+      fn: wrappedFn
+    });
+    return {
+      subscriber_id: subscriberId,
+      topic_path: listener.path ?? "",
+      scope_path: listener.scope ?? ""
+    };
+  });
+  const pipeline = store._internal.pipeline;
+  const registrationId = `sideEffects-${id}`;
+  const result = pipeline.registerSideEffects({
+    registration_id: registrationId,
+    ...syncPairs.length > 0 && { sync_pairs: syncPairs },
+    ...flipPairs.length > 0 && { flip_pairs: flipPairs },
+    ...aggregationPairs.length > 0 && { aggregation_pairs: aggregationPairs },
+    ...computationPairs.length > 0 && {
+      computation_pairs: computationPairs
+    },
+    ...clearPaths && clearPaths.length > 0 && { clear_paths: clearPaths },
+    ...listeners && listeners.length > 0 && { listeners }
+  });
+  if (result.sync_changes.length > 0) {
+    applyBatch(
+      result.sync_changes.map((c) => [c.path, c.value, {}]),
+      store.state
+    );
+  }
+  if (result.aggregation_changes.length > 0) {
+    applyBatch(
+      result.aggregation_changes.map((c) => [c.path, c.value, {}]),
+      store.state
+    );
+  }
+  if (result.computation_changes.length > 0) {
+    applyBatch(
+      result.computation_changes.map((c) => [c.path, c.value, {}]),
+      store.state
+    );
+  }
+  const cleanup = () => {
+    pipeline.unregisterSideEffects(registrationId);
+    effects.listeners?.forEach((_listener, index) => {
+      if (listeners && listeners[index]) {
+        store._internal.graphs.listenerHandlers.delete(
+          listeners[index].subscriber_id
+        );
+      }
+    });
+    store._internal.registrations.sideEffectCleanups.delete(id);
+  };
+  store._internal.registrations.sideEffectCleanups.set(id, cleanup);
+  return cleanup;
+};
+
+// src/store/provider.tsx
+import { useLayoutEffect, useRef } from "react";
+import { proxy, ref } from "valtio";
+
+// src/core/defaults.ts
+var DEFAULT_STORE_CONFIG = {
+  errorStorePath: "_errors",
+  maxIterations: 100,
+  debug: {
+    timing: false,
+    timingThreshold: 5,
+    track: false
+  },
+  useLegacyImplementation: false
+};
+
+// src/utils/deep-clone.ts
+import _deepClone from "@jsbits/deep-clone";
+var assertNoCycles = (value) => {
+  if (value === null || typeof value !== "object") return;
+  const ancestors = /* @__PURE__ */ new WeakSet();
+  const walk = (obj, path) => {
+    if (ancestors.has(obj)) {
+      throw new Error(
+        `[deepClone] Circular reference detected at "${path}". State objects must not contain self-references.`
+      );
+    }
+    ancestors.add(obj);
+    const descriptors = Object.getOwnPropertyDescriptors(obj);
+    for (const [key, desc] of Object.entries(descriptors)) {
+      if (desc.get) continue;
+      if (desc.value !== null && typeof desc.value === "object") {
+        walk(desc.value, path ? `${path}.${key}` : key);
+      }
+    }
+    ancestors.delete(obj);
+  };
+  walk(value, "");
+};
+var deepClone = (value) => {
+  assertNoCycles(value);
+  return _deepClone(value, true);
+};
+
+// src/utils/deep-merge.ts
+var deepMerge = (target, source) => {
+  if (!source) return target;
+  const result = { ...target };
+  for (const key in source) {
+    if (!Object.prototype.hasOwnProperty.call(source, key)) continue;
+    const sourceValue = source[key];
+    const targetValue = target[key];
+    if (is.undefined(sourceValue)) {
+      continue;
+    }
+    if (is.object(sourceValue) && is.object(targetValue)) {
+      result[key] = deepMerge(
+        targetValue,
+        sourceValue
+      );
+    } else {
+      result[key] = sourceValue;
+    }
+  }
+  return result;
+};
+
+// src/utils/derive-values.ts
+import { computed } from "valtio-reactive";
+var extractGetters = (obj, prefix = "") => {
+  const base = {};
+  const computed2 = {};
+  const descriptors = Object.getOwnPropertyDescriptors(obj);
+  for (const [key, descriptor] of Object.entries(descriptors)) {
+    if (!descriptor.enumerable || is.symbol(key)) continue;
+    const fullPath = prefix ? `${prefix}.${key}` : key;
+    if (descriptor.get) {
+      computed2[fullPath] = { get: descriptor.get, parentPath: prefix };
+    } else if (is.object(descriptor.value)) {
+      const nested = extractGetters(descriptor.value, fullPath);
+      base[key] = nested.base;
+      Object.assign(computed2, nested.computed);
+    } else {
+      base[key] = descriptor.value;
+    }
+  }
+  return { base, computed: computed2 };
+};
+var prepareInitialState = (rawState) => {
+  const { base, computed: getterMap } = extractGetters(rawState);
+  return { initialState: base, getterMap };
+};
+var attachComputedGetters = (stateProxy, getterMap) => {
+  if (Object.keys(getterMap).length === 0) return;
+  for (const [dotPath, { get: getterFn, parentPath }] of Object.entries(
+    getterMap
+  )) {
+    const parts = dotPath.split(".");
+    const propName = parts.pop();
+    const parentObj = parts.length > 0 ? dot.get__unsafe(stateProxy, parts.join(".")) : stateProxy;
+    Object.defineProperty(parentObj, propName, {
+      get() {
+        const ctx = parentPath ? dot.get__unsafe(stateProxy, parentPath) : stateProxy;
+        return getterFn.call(ctx);
+      },
+      enumerable: true,
+      configurable: true
+    });
+  }
+  const computedDefs = {};
+  for (const [dotPath, { get: getterFn, parentPath }] of Object.entries(
+    getterMap
+  )) {
+    computedDefs[dotPath] = () => {
+      const parent = parentPath ? dot.get__unsafe(stateProxy, parentPath) : stateProxy;
+      return getterFn.call(parent);
+    };
+  }
+  const computedProxy = computed(computedDefs);
+  for (const dotPath of Object.keys(getterMap)) {
+    const parts = dotPath.split(".");
+    const propName = parts.pop();
+    const parentObj = parts.length > 0 ? dot.get__unsafe(stateProxy, parts.join(".")) : stateProxy;
+    Object.defineProperty(parentObj, propName, {
+      get: () => computedProxy[dotPath],
+      enumerable: true,
+      configurable: true
+    });
+  }
+};
+
+// src/utils/timing.ts
+var defaultOnSlowOperation = (event) => {
+  console.warn(
+    `[apex-state] Slow ${event.type}: ${event.path}/${event.name} took ${event.duration.toFixed(2)}ms (threshold: ${event.threshold}ms)`
+  );
+};
+var defaultOnTimingSummary = (summary) => {
+  if (summary.slowOperations.length > 0 || summary.totalDuration > 16) {
+    console.warn(
+      `[apex-state] ${summary.type}: ${summary.operationCount} ops in ${summary.totalDuration.toFixed(2)}ms (${summary.slowOperations.length} slow)`
+    );
+  }
+};
+var createTypeState = () => ({
+  totalDuration: 0,
+  operationCount: 0,
+  slowOperations: [],
+  warnedOperations: /* @__PURE__ */ new Set()
+});
+var createTiming = (options) => {
+  const {
+    timing,
+    timingThreshold,
+    onSlowOperation = defaultOnSlowOperation,
+    onSummary = defaultOnTimingSummary
+  } = options;
+  if (!timing) {
+    return {
+      run: (_type, fn) => fn(),
+      reportBatch: () => {
+      }
+    };
+  }
+  const state = {
+    concerns: createTypeState(),
+    listeners: createTypeState(),
+    registration: createTypeState()
+  };
+  return {
+    run: (type, fn, meta) => {
+      const start = performance.now();
+      const result = fn();
+      const duration = performance.now() - start;
+      const typeState = state[type];
+      typeState.totalDuration += duration;
+      typeState.operationCount++;
+      if (duration > timingThreshold) {
+        const event = {
+          ...meta,
+          type,
+          duration,
+          threshold: timingThreshold
+        };
+        typeState.slowOperations.push(event);
+        const key = `${type}:${meta.path}:${meta.name}`;
+        if (!typeState.warnedOperations.has(key)) {
+          typeState.warnedOperations.add(key);
+          onSlowOperation(event);
+        }
+      }
+      return result;
+    },
+    reportBatch: (type) => {
+      const typeState = state[type];
+      onSummary({
+        type,
+        totalDuration: typeState.totalDuration,
+        operationCount: typeState.operationCount,
+        slowOperations: typeState.slowOperations
+      });
+      typeState.totalDuration = 0;
+      typeState.operationCount = 0;
+      typeState.slowOperations = [];
+    }
+  };
+};
+
+// src/wasm/lifecycle.tsx
+import { useEffect, useState } from "react";
+
+// 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 }
+]);
+var changesToWasm = (changes) => changes.map(({ path, value }) => ({ path, value_json: fastStringify(value) }));
+var wasmChangesToJs = (wasmChanges) => wasmChanges.map(({ path, value_json, origin }) => ({
+  path,
+  value: fastParse(value_json),
+  ...origin ? { origin } : {}
+}));
+var createWasmPipeline = () => {
+  const wasm = getWasmInstance();
+  const id = wasm.pipeline_create();
+  const schemas = /* @__PURE__ */ new Map();
+  return {
+    id,
+    shadowInit: (state) => {
+      wasm.shadow_init(id, state);
+    },
+    shadowDump: () => JSON.parse(wasm.shadow_dump(id)),
+    processChanges: (changes) => {
+      const result = wasm.process_changes(
+        id,
+        changesToWasm(changes)
+      );
+      const stateChanges = wasmChangesToJs(result.state_changes);
+      return {
+        state_changes: stateChanges,
+        changes: stateChanges,
+        validators_to_run: result.validators_to_run,
+        execution_plan: result.execution_plan,
+        has_work: result.has_work
+      };
+    },
+    pipelineFinalize: (jsChanges) => {
+      const result = wasm.pipeline_finalize(
+        id,
+        changesToWasm(jsChanges)
+      );
+      return {
+        state_changes: wasmChangesToJs(result.state_changes)
+      };
+    },
+    registerSideEffects: (reg) => {
+      const resultJson = wasm.register_side_effects(
+        id,
+        JSON.stringify(reg)
+      );
+      return {
+        sync_changes: wasmChangesToJs(resultJson.sync_changes),
+        aggregation_changes: wasmChangesToJs(resultJson.aggregation_changes),
+        computation_changes: wasmChangesToJs(resultJson.computation_changes),
+        registered_listener_ids: resultJson.registered_listener_ids
+      };
+    },
+    unregisterSideEffects: (registrationId) => {
+      wasm.unregister_side_effects(id, registrationId);
+    },
+    registerConcerns: (reg) => {
+      const resultJson = wasm.register_concerns(
+        id,
+        JSON.stringify(reg)
+      );
+      return {
+        bool_logic_changes: wasmChangesToJs(resultJson.bool_logic_changes),
+        registered_logic_ids: resultJson.registered_logic_ids,
+        registered_validator_ids: resultJson.registered_validator_ids,
+        value_logic_changes: wasmChangesToJs(resultJson.value_logic_changes),
+        registered_value_logic_ids: resultJson.registered_value_logic_ids
+      };
+    },
+    unregisterConcerns: (registrationId) => {
+      wasm.unregister_concerns(id, registrationId);
+    },
+    registerBoolLogic: (outputPath, tree) => wasm.register_boollogic(id, outputPath, JSON.stringify(tree)),
+    unregisterBoolLogic: (logicId) => {
+      wasm.unregister_boollogic(id, logicId);
+    },
+    pipelineReset: () => {
+      wasm.pipeline_reset(id);
+    },
+    destroy: () => {
+      wasm.pipeline_destroy(id);
+      schemas.clear();
+    },
+    validatorSchemas: schemas
+  };
+};
+
+// src/wasm/lifecycle.tsx
+import { Fragment, jsx } from "react/jsx-runtime";
+var wasmInstance = null;
+var loadingPromise = null;
+var loadWasm = async () => {
+  if (wasmInstance) return wasmInstance;
+  if (loadingPromise) {
+    await loadingPromise;
+    return wasmInstance;
+  }
+  loadingPromise = (async () => {
+    const wasmModule = await import("./apex_state_wasm-WOOTVUVC.js");
+    if (typeof wasmModule.default === "function") {
+      await wasmModule.default();
+    }
+    wasmInstance = wasmModule;
+  })();
+  await loadingPromise;
+  return wasmInstance;
+};
+var isWasmLoaded = () => wasmInstance !== null;
+var initPipeline = (internal, initialState) => {
+  const pipeline = createWasmPipeline();
+  pipeline.shadowInit(initialState);
+  internal.pipeline = pipeline;
+};
+var WasmGate = ({ children }) => {
+  const [loaded, setLoaded] = useState(isWasmLoaded);
+  useEffect(() => {
+    if (loaded) return;
+    let cancelled = false;
+    loadWasm().then(() => {
+      if (!cancelled) setLoaded(true);
+    }).catch((error) => {
+      console.error("[apex-state] Failed to load WASM:", error);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [loaded]);
+  if (!loaded) return null;
+  return /* @__PURE__ */ jsx(Fragment, { children });
+};
+WasmGate.displayName = "WasmGate";
+var getWasmInstance = () => {
+  if (!wasmInstance) {
+    throw new Error("WASM not loaded. Call loadWasm() first.");
+  }
+  return wasmInstance;
+};
+
+// src/store/provider.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var createInternalState = (config) => ({
+  graphs: {
+    sync: createPathGroups("sync"),
+    flip: createPathGroups("flip"),
+    listeners: /* @__PURE__ */ new Map(),
+    sortedListenerPaths: [],
+    listenerHandlers: /* @__PURE__ */ new Map()
+  },
+  registrations: {
+    concerns: /* @__PURE__ */ new Map(),
+    effectCleanups: /* @__PURE__ */ new Set(),
+    sideEffectCleanups: /* @__PURE__ */ new Map(),
+    aggregations: /* @__PURE__ */ new Map()
+  },
+  processing: {
+    queue: []
+  },
+  timing: createTiming(config.debug),
+  config,
+  pipeline: null
+});
+var createProvider = (storeConfig) => {
+  const resolvedConfig = deepMerge(DEFAULT_STORE_CONFIG, storeConfig);
+  const buildStore = (rawInitialState) => {
+    const prepared = prepareInitialState(deepClone(rawInitialState));
+    const internal = createInternalState(resolvedConfig);
+    initPipeline(internal, prepared.initialState);
+    const debugTrack = resolvedConfig.debug.track ? {
+      calls: [],
+      clear: () => {
+        debugTrack.calls.length = 0;
+      }
+    } : null;
+    const stateProxy = proxy(prepared.initialState);
+    attachComputedGetters(stateProxy, prepared.getterMap);
+    return {
+      // state: Application data (tracked by valtio)
+      // User actions WRITE to this, effects READ from this
+      state: stateProxy,
+      // _concerns: Computed concern values (tracked by valtio)
+      // Effects WRITE to this, UI components READ from this
+      _concerns: proxy({}),
+      // _internal: Graphs, registrations, processing (NOT tracked)
+      // Wrapped in ref() to prevent tracking even if store is later wrapped in a proxy
+      _internal: ref(internal),
+      // _debug: Tracking data for testing/debugging (only when debug.track enabled)
+      _debug: debugTrack ? ref(debugTrack) : null
+    };
+  };
+  const StoreProvider = ({ initialState, children }) => {
+    const storeRef = useRef(buildStore(initialState));
+    const internal = storeRef.current._internal;
+    useLayoutEffect(() => {
+      if (internal._destroyTimer) {
+        clearTimeout(internal._destroyTimer);
+        internal._destroyTimer = void 0;
+      }
+      return () => {
+        internal._destroyTimer = setTimeout(() => {
+          internal.pipeline?.destroy();
+          internal.pipeline = null;
+          internal._destroyTimer = void 0;
+        }, 1e4);
+      };
+    }, [internal]);
+    return /* @__PURE__ */ jsx2(
+      StoreContext.Provider,
+      {
+        value: storeRef.current,
+        children
+      }
+    );
+  };
+  StoreProvider.displayName = "StoreProvider";
+  const Provider = (props) => /* @__PURE__ */ jsx2(WasmGate, { children: /* @__PURE__ */ jsx2(StoreProvider, { ...props }) });
+  Provider.displayName = "StoreProvider";
+  return Provider;
+};
+
+// src/store/create-store.ts
+var createGenericStore = (config) => {
+  const Provider = createProvider(config);
+  const _useFieldValue = (path) => {
+    const store = useStoreContext();
+    const snap = useSnapshot(store.state);
+    const value = dot.get(snap, path);
+    const setValue = useCallback(
+      (newValue, meta) => {
+        const changes = [
+          [path, newValue, meta || {}]
+        ];
+        const processChanges2 = store._internal.config.useLegacyImplementation ? processChangesLegacy : processChangesWasm;
+        processChanges2(store, changes);
+      },
+      [store, path]
+    );
+    return { store, value, setValue };
+  };
+  const useFieldStore = (path) => {
+    const { store, value, setValue } = _useFieldValue(path);
+    const concernsSnap = useSnapshot(store._concerns);
+    const allConcerns = concernsSnap[path] || {};
+    return { value, setValue, ...allConcerns };
+  };
+  const useStore = (path) => {
+    const { value, setValue } = _useFieldValue(path);
+    return [value, setValue];
+  };
+  const useJitStore = () => {
+    const store = useStoreContext();
+    const proxyValue = useSnapshot(store.state);
+    const setChanges = useCallback(
+      (changes) => {
+        const processChanges2 = store._internal.config.useLegacyImplementation ? processChangesLegacy : processChangesWasm;
+        processChanges2(store, changes);
+      },
+      [store]
+    );
+    const getState = useCallback(() => {
+      return snapshot3(store.state);
+    }, [store]);
+    return { proxyValue, setChanges, getState };
+  };
+  const useSideEffects = (id, effects) => {
+    const store = useStoreContext();
+    useLayoutEffect2(() => {
+      const registerSideEffects3 = store._internal.config.useLegacyImplementation ? registerSideEffects : registerSideEffects2;
+      return registerSideEffects3(store, id, effects);
+    }, [store, id, effects]);
+  };
+  const useConcerns = (id, registration, customConcerns) => {
+    const store = useStoreContext();
+    const concerns = customConcerns || defaultConcerns;
+    useLayoutEffect2(() => {
+      const registerConcernEffects3 = store._internal.config.useLegacyImplementation ? registerConcernEffects : registerConcernEffects2;
+      return registerConcernEffects3(store, registration, concerns);
+    }, [store, id, registration, customConcerns]);
+  };
+  const withConcerns = (selection) => {
+    return {
+      useFieldStore: (path) => {
+        const { store, value, setValue } = _useFieldValue(path);
+        const concernsSnap = useSnapshot(store._concerns);
+        const allConcerns = concernsSnap[path] || {};
+        const selectedConcerns = Object.keys(selection).reduce(
+          (acc, key) => {
+            if (selection[key] && Object.prototype.hasOwnProperty.call(allConcerns, key)) {
+              acc[key] = allConcerns[key];
+            }
+            return acc;
+          },
+          {}
+        );
+        return { value, setValue, ...selectedConcerns };
+      }
+    };
+  };
+  const withMeta = (presetMeta) => ({
+    useFieldStore: (path) => {
+      const { store, value, setValue: originalSetValue } = _useFieldValue(path);
+      const concernsSnap = useSnapshot(store._concerns);
+      const allConcerns = concernsSnap[path] || {};
+      const setValue = useCallback(
+        (newValue, meta) => {
+          originalSetValue(newValue, { ...presetMeta, ...meta });
+        },
+        [originalSetValue]
+      );
+      return { value, setValue, ...allConcerns };
+    }
+  });
+  return {
+    Provider,
+    useFieldStore,
+    useStore,
+    useJitStore,
+    useSideEffects,
+    useConcerns,
+    withConcerns,
+    withMeta
+  };
+};
+
+// 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 as useRef2 } from "react";
+var useKeyboardSelect = (field, config) => {
+  const { setValue } = field;
+  const { options, debounceMs = 500, matchFromStart = true } = config;
+  const searchRef = useRef2("");
+  const timeoutRef = useRef2(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 useRef3 } from "react";
+var useThrottledField = (field, config) => {
+  const { setValue: originalSetValue, ...rest } = field;
+  const { ms } = config;
+  const throttleRef = useRef3({
+    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 } from "react";
+var useTransformedField = (field, config) => {
+  const { value: storedValue, setValue: setStoredValue, ...rest } = field;
+  const { to, from } = config;
+  const value = useMemo(() => 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;
+};
+
+export {
+  is,
+  dot,
+  evaluateBoolLogic,
+  extractPlaceholders,
+  interpolateTemplate,
+  prebuilts_exports,
+  findConcern,
+  defaultConcerns,
+  registerFlipPair,
+  registerListenerLegacy,
+  registerSyncPairsBatch,
+  registerSideEffects,
+  deepClone,
+  createGenericStore,
+  useBufferedField,
+  useKeyboardSelect,
+  useThrottledField,
+  useTransformedField,
+  _,
+  hashKey,
+  applyChangesToObject
+};
+//# sourceMappingURL=chunk-SLJZLVMQ.js.map