@hurum/core 0.0.1

package/dist/index.js

@@ -0,0 +1,1404 @@
+// src/events.ts
+var EVENT_CREATOR_BRAND = /* @__PURE__ */ Symbol("hurum/event-creator");
+function Event() {
+  return {};
+}
+function Events(prefix, events) {
+  const result = {};
+  for (const key of Object.keys(events)) {
+    const type = `${prefix}/${key}`;
+    const creator = function(payload) {
+      return { ...payload, type };
+    };
+    Object.defineProperty(creator, "type", {
+      value: type,
+      writable: false,
+      enumerable: true,
+      configurable: false
+    });
+    Object.defineProperty(creator, EVENT_CREATOR_BRAND, {
+      value: true,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+    result[key] = creator;
+  }
+  return result;
+}
+function isEventCreator(value) {
+  return typeof value === "function" && EVENT_CREATOR_BRAND in value && value[EVENT_CREATOR_BRAND] === true;
+}
+
+// src/command-executor.ts
+var COMMAND_BRAND = /* @__PURE__ */ Symbol("hurum/command");
+var EXECUTOR_BRAND = /* @__PURE__ */ Symbol("hurum/executor");
+function CommandExecutor(nameOrFn, maybeFn) {
+  const name = typeof nameOrFn === "string" ? nameOrFn : nameOrFn.name || void 0;
+  const fn = typeof nameOrFn === "string" ? maybeFn : nameOrFn;
+  const commandId = /* @__PURE__ */ Symbol("hurum/command-id");
+  const command = {
+    [COMMAND_BRAND]: commandId,
+    ...name ? { name } : {}
+  };
+  const executor = {
+    [EXECUTOR_BRAND]: true,
+    __command: command,
+    __fn: fn
+  };
+  return [command, executor];
+}
+CommandExecutor.passthrough = function passthrough(nameOrEventCreator, eventCreatorOrTransform, maybeTransform) {
+  let name;
+  let eventCreator;
+  let transform;
+  if (typeof nameOrEventCreator === "string") {
+    name = nameOrEventCreator;
+    eventCreator = eventCreatorOrTransform;
+    transform = maybeTransform;
+  } else {
+    eventCreator = nameOrEventCreator;
+    transform = eventCreatorOrTransform;
+  }
+  const commandId = /* @__PURE__ */ Symbol("hurum/command-id");
+  const command = {
+    [COMMAND_BRAND]: commandId,
+    ...name ? { name } : {}
+  };
+  const executorFn = (input, { emit }) => {
+    const payload = transform ? transform(input) : input;
+    emit(eventCreator(payload));
+  };
+  const executor = {
+    [EXECUTOR_BRAND]: true,
+    __command: command,
+    __fn: executorFn
+  };
+  return [command, executor];
+};
+function getCommandId(command) {
+  return command[COMMAND_BRAND];
+}
+function getExecutorCommand(executor) {
+  return executor.__command;
+}
+function getExecutorFn(executor) {
+  return executor.__fn;
+}
+
+// src/intent.ts
+var INTENT_BRAND = /* @__PURE__ */ Symbol("hurum/intent");
+var INTENTS_BRAND = /* @__PURE__ */ Symbol("hurum/intents");
+var PREPARED_INTENT_BRAND = /* @__PURE__ */ Symbol("hurum/prepared-intent");
+function createIntentAction(mode, commands) {
+  const action = function(payload) {
+    return {
+      [PREPARED_INTENT_BRAND]: true,
+      intent: action,
+      payload
+    };
+  };
+  Object.defineProperty(action, INTENT_BRAND, {
+    value: true,
+    writable: false,
+    enumerable: false,
+    configurable: false
+  });
+  Object.defineProperty(action, "commands", {
+    value: commands,
+    writable: false,
+    enumerable: true,
+    configurable: false
+  });
+  Object.defineProperty(action, "mode", {
+    value: mode,
+    writable: false,
+    enumerable: true,
+    configurable: false
+  });
+  Object.defineProperty(action, "name", {
+    value: void 0,
+    writable: false,
+    enumerable: true,
+    configurable: true
+  });
+  return action;
+}
+function Intent(...commands) {
+  return createIntentAction("sequential", commands);
+}
+Intent.all = function all(...commands) {
+  return createIntentAction("all", commands);
+};
+Intent.allSettled = function allSettled(...commands) {
+  return createIntentAction("allSettled", commands);
+};
+function Intents(prefix, intents) {
+  const container = { ...intents };
+  for (const [key, descriptor] of Object.entries(container)) {
+    if (isIntentDescriptor(descriptor)) {
+      Object.defineProperty(descriptor, "name", {
+        value: `${prefix}/${key}`,
+        writable: false,
+        enumerable: true,
+        configurable: false
+      });
+    }
+  }
+  Object.defineProperty(container, INTENTS_BRAND, {
+    value: true,
+    writable: false,
+    enumerable: false,
+    configurable: false
+  });
+  Object.defineProperty(container, "__prefix", {
+    value: prefix,
+    writable: false,
+    enumerable: false,
+    configurable: false
+  });
+  return container;
+}
+function isIntentDescriptor(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null && INTENT_BRAND in value;
+}
+function isPreparedIntent(value) {
+  return typeof value === "object" && value !== null && PREPARED_INTENT_BRAND in value;
+}
+
+// src/computed.ts
+function createTrackingProxy(state, accessed) {
+  return new Proxy(state, {
+    get(target, prop, receiver) {
+      if (typeof prop === "string") {
+        accessed.add(prop);
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+function initializeComputedNodes(rawState, computedDef) {
+  if (!computedDef) return [];
+  const nodes = [];
+  const nodesByName = /* @__PURE__ */ new Map();
+  for (const [name, fn] of Object.entries(computedDef)) {
+    const accessed = /* @__PURE__ */ new Set();
+    const trackingProxy = createTrackingProxy(rawState, accessed);
+    const value = fn(trackingProxy);
+    const node = {
+      name,
+      fn,
+      deps: accessed,
+      value,
+      prevValue: value
+    };
+    nodes.push(node);
+    nodesByName.set(name, node);
+  }
+  const sorted = topologicalSort(nodes, nodesByName);
+  return sorted;
+}
+function topologicalSort(nodes, nodesByName) {
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const sorted = [];
+  function visit(node) {
+    if (visited.has(node.name)) return;
+    if (visiting.has(node.name)) {
+      throw new Error(
+        `Circular dependency detected in computed fields: ${node.name}`
+      );
+    }
+    visiting.add(node.name);
+    for (const dep of node.deps) {
+      const depNode = nodesByName.get(dep);
+      if (depNode) {
+        visit(depNode);
+      }
+    }
+    visiting.delete(node.name);
+    visited.add(node.name);
+    sorted.push(node);
+  }
+  for (const node of nodes) {
+    visit(node);
+  }
+  return sorted;
+}
+function evaluateComputedNodes(nodes, rawState, changedKeys) {
+  const values = {};
+  let anyChanged = false;
+  for (const node of nodes) {
+    let needsReeval = false;
+    for (const dep of node.deps) {
+      if (changedKeys.has(dep)) {
+        needsReeval = true;
+        break;
+      }
+    }
+    if (needsReeval) {
+      const accessed = /* @__PURE__ */ new Set();
+      const trackingProxy = createTrackingProxy(rawState, accessed);
+      const newValue = node.fn(trackingProxy);
+      node.deps = accessed;
+      if (!structuralEqual(node.value, newValue)) {
+        node.prevValue = node.value;
+        node.value = newValue;
+        anyChanged = true;
+        changedKeys.add(node.name);
+      }
+    }
+    values[node.name] = node.value;
+  }
+  return { values, changed: anyChanged };
+}
+function structuralEqual(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null) return false;
+  if (typeof a !== typeof b) return false;
+  if (typeof a !== "object") return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!structuralEqual(a[i], b[i])) return false;
+    }
+    return true;
+  }
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  for (const key of keysA) {
+    if (!structuralEqual(a[key], b[key])) return false;
+  }
+  return true;
+}
+
+// src/nested.ts
+var NESTED_BRAND = /* @__PURE__ */ Symbol("hurum/nested");
+function Nested(store) {
+  return {
+    [NESTED_BRAND]: true,
+    kind: "single",
+    store
+  };
+}
+Nested.array = function array(store) {
+  return {
+    [NESTED_BRAND]: true,
+    kind: "array",
+    store
+  };
+};
+Nested.map = function map(store) {
+  return {
+    [NESTED_BRAND]: true,
+    kind: "map",
+    store
+  };
+};
+function isNestedMarker(value) {
+  return typeof value === "object" && value !== null && NESTED_BRAND in value;
+}
+
+// src/selector.ts
+function isSelector(value) {
+  return typeof value === "object" && value !== null && "__selectorBrand" in value && value.__selectorBrand === true;
+}
+function createSelector(getState, storeSubscribe, selectorFn) {
+  let lastState;
+  let lastResult;
+  let initialized = false;
+  function compute() {
+    const currentState = getState();
+    if (initialized && currentState === lastState) {
+      return lastResult;
+    }
+    const newResult = selectorFn(currentState);
+    if (initialized && structuralEqual(lastResult, newResult)) {
+      lastState = currentState;
+      return lastResult;
+    }
+    lastState = currentState;
+    lastResult = newResult;
+    initialized = true;
+    return newResult;
+  }
+  compute();
+  return {
+    get: compute,
+    subscribe(cb) {
+      return storeSubscribe(() => {
+        const prev = lastResult;
+        const next = compute();
+        if (prev !== next) {
+          cb(next);
+        }
+      });
+    },
+    __selectorBrand: true
+  };
+}
+
+// src/store.ts
+var STORE_DEF_BRAND = /* @__PURE__ */ Symbol("hurum/store-def");
+var STORE_INSTANCE_BRAND = /* @__PURE__ */ Symbol("hurum/store-instance");
+var IS_DEV = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" && globalThis.process?.env?.["NODE_ENV"] !== "production";
+var MAX_RELAY_DEPTH = 5;
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function deepMerge(base, override) {
+  const result = { ...base };
+  for (const key of Object.keys(override)) {
+    const baseVal = base[key];
+    const overVal = override[key];
+    if (isPlainObject(baseVal) && isPlainObject(overVal)) {
+      result[key] = deepMerge(baseVal, overVal);
+    } else if (overVal !== void 0) {
+      result[key] = overVal;
+    }
+  }
+  return result;
+}
+function createBuilder(cfg) {
+  function buildConfig() {
+    return {
+      state: cfg.state,
+      on: cfg.on,
+      computed: cfg.computed,
+      intents: cfg.intents,
+      executors: cfg.executors,
+      relay: cfg.relay,
+      middleware: cfg.middleware,
+      childDepsMap: cfg.childDepsMap
+    };
+  }
+  function doCreate(options) {
+    const config = buildConfig();
+    const rawStateTemplate = {};
+    const nestedFields = {};
+    for (const [key, value] of Object.entries(config.state)) {
+      if (isNestedMarker(value)) {
+        nestedFields[key] = value;
+      } else {
+        rawStateTemplate[key] = value;
+      }
+    }
+    return createStoreInstance(config, rawStateTemplate, nestedFields, options);
+  }
+  const builder = {
+    on(eventOrNamespace, handlerOrMap) {
+      const newHandlers = {};
+      if (isEventCreator(eventOrNamespace)) {
+        const event = eventOrNamespace;
+        newHandlers[event.type] = handlerOrMap;
+      } else {
+        const namespace = eventOrNamespace;
+        const handlers = handlerOrMap;
+        for (const key of Object.keys(handlers)) {
+          const eventCreator = namespace[key];
+          if (eventCreator && typeof eventCreator === "function" && "type" in eventCreator) {
+            newHandlers[eventCreator.type] = handlers[key];
+          }
+        }
+      }
+      return createBuilder({
+        ...cfg,
+        on: { ...cfg.on, ...newHandlers }
+      });
+    },
+    computed(def) {
+      return createBuilder({
+        ...cfg,
+        computed: { ...cfg.computed, ...def }
+      });
+    },
+    intents(container) {
+      return createBuilder({
+        ...cfg,
+        intents: container
+      });
+    },
+    executors(...execs) {
+      return createBuilder({
+        ...cfg,
+        executors: [...cfg.executors ?? [], ...execs]
+      });
+    },
+    deps() {
+      return createBuilder({ ...cfg });
+    },
+    childDeps(key, mapper) {
+      return createBuilder({
+        ...cfg,
+        childDepsMap: {
+          ...cfg.childDepsMap,
+          [key]: mapper
+        }
+      });
+    },
+    relay(event, handler) {
+      return createBuilder({
+        ...cfg,
+        relay: { ...cfg.relay, [event.type]: handler }
+      });
+    },
+    middleware(...mws) {
+      const resolvedMws = mws.map((mw) => {
+        if ("create" in mw && typeof mw.create === "function") {
+          return mw.create();
+        }
+        return mw;
+      });
+      return createBuilder({
+        ...cfg,
+        middleware: [...cfg.middleware ?? [], ...resolvedMws]
+      });
+    },
+    create: doCreate
+  };
+  Object.defineProperty(builder, STORE_DEF_BRAND, {
+    value: true,
+    writable: false,
+    enumerable: false,
+    configurable: false
+  });
+  Object.defineProperty(builder, "__config", {
+    get: buildConfig,
+    enumerable: false,
+    configurable: false
+  });
+  return builder;
+}
+function Store(config) {
+  return createBuilder({
+    state: config.state
+  });
+}
+function isStoreDefinition(value) {
+  return typeof value === "object" && value !== null && STORE_DEF_BRAND in value;
+}
+function isStoreInstance(value) {
+  return typeof value === "object" && value !== null && STORE_INSTANCE_BRAND in value;
+}
+var instanceIdCounter = 0;
+function nextInstanceId() {
+  return `nested-${++instanceIdCounter}`;
+}
+function createSendProxy(send, intentsContainer) {
+  const intentLookup = /* @__PURE__ */ new Map();
+  if (intentsContainer) {
+    for (const [key, value] of Object.entries(intentsContainer)) {
+      if (isIntentDescriptor(value)) {
+        intentLookup.set(key, value);
+      }
+    }
+  }
+  const boundIntents = /* @__PURE__ */ new Map();
+  return new Proxy(send, {
+    get(_target, prop) {
+      if (typeof prop !== "string") return void 0;
+      if (prop === "bind" || prop === "call" || prop === "apply" || prop === "length" || prop === "name" || prop === "prototype") {
+        return send[prop];
+      }
+      let bound = boundIntents.get(prop);
+      if (!bound) {
+        const descriptor = intentLookup.get(prop);
+        if (!descriptor) {
+          if (IS_DEV) {
+            console.warn(`[hurum] No intent named "${prop}" registered on this store.`);
+          }
+          return void 0;
+        }
+        bound = (payload) => send(descriptor, payload);
+        boundIntents.set(prop, bound);
+      }
+      return bound;
+    },
+    apply(_target, _thisArg, args) {
+      return send(args[0], args[1]);
+    }
+  });
+}
+function resolveNestedSingleDefaults(marker) {
+  const childDef = marker.store;
+  const childState = childDef.__config.state;
+  const safe = {};
+  for (const [k, v] of Object.entries(childState)) {
+    if (isNestedMarker(v)) {
+      if (v.kind === "array") safe[k] = [];
+      else if (v.kind === "map") safe[k] = {};
+      else safe[k] = resolveNestedSingleDefaults(v);
+    } else {
+      safe[k] = v;
+    }
+  }
+  return safe;
+}
+function createStoreInstance(config, rawStateTemplate, nestedFields, options) {
+  let rawState = { ...rawStateTemplate };
+  if (options?.initialState) {
+    rawState = deepMerge(rawState, options.initialState);
+  }
+  let deps = {};
+  if (options?.deps) {
+    deps = { ...deps, ...options.deps };
+  }
+  const executorMap = /* @__PURE__ */ new Map();
+  if (config.executors) {
+    for (const executor of config.executors) {
+      const command = getExecutorCommand(executor);
+      const commandId = getCommandId(command);
+      executorMap.set(commandId, getExecutorFn(executor));
+    }
+  }
+  let stateForInitialComputed = rawState;
+  if (Object.keys(nestedFields).length > 0) {
+    const nestedDefaults = {};
+    for (const [key, marker] of Object.entries(nestedFields)) {
+      if (marker.kind === "array") nestedDefaults[key] = [];
+      else if (marker.kind === "map") nestedDefaults[key] = {};
+      else nestedDefaults[key] = resolveNestedSingleDefaults(marker);
+    }
+    stateForInitialComputed = { ...rawState, ...nestedDefaults };
+  }
+  const computedNodes = initializeComputedNodes(
+    stateForInitialComputed,
+    config.computed
+  );
+  let computedValues = {};
+  for (const node of computedNodes) {
+    computedValues[node.name] = node.value;
+  }
+  let cachedCombinedState = null;
+  function invalidateCache() {
+    cachedCombinedState = null;
+  }
+  const stateListeners = /* @__PURE__ */ new Set();
+  const eventListeners = /* @__PURE__ */ new Set();
+  const runningControllers = /* @__PURE__ */ new Map();
+  let runningCount = 0;
+  let disposed = false;
+  let relayDepth = 0;
+  const relayProcessing = /* @__PURE__ */ new Set();
+  const eventLog = [];
+  const stateSnapshots = [];
+  const nestedManagers = [];
+  const scope = {};
+  function getNestedStates() {
+    const nestedState = {};
+    for (const mgr of nestedManagers) {
+      if (mgr.kind === "single") {
+        nestedState[mgr.key] = mgr.instance ? mgr.instance.getState() : null;
+      } else if (mgr.kind === "array") {
+        const arr = [];
+        for (const [, entry] of mgr.instances) {
+          arr.push(entry.instance.getState());
+        }
+        nestedState[mgr.key] = arr;
+      } else if (mgr.kind === "map") {
+        const rec = {};
+        for (const [key, entry] of mgr.instances) {
+          rec[key] = entry.instance.getState();
+        }
+        nestedState[mgr.key] = rec;
+      }
+    }
+    return nestedState;
+  }
+  function getCombinedState() {
+    if (cachedCombinedState !== null) return cachedCombinedState;
+    cachedCombinedState = { ...rawState, ...computedValues, ...getNestedStates() };
+    return cachedCombinedState;
+  }
+  function recomputeFromNestedChange() {
+    invalidateCache();
+    if (computedNodes.length === 0) return;
+    const nestedKeys = new Set(nestedManagers.map((m) => m.key));
+    if (nestedKeys.size === 0) return;
+    const stateForComputed = { ...rawState, ...getNestedStates() };
+    const { values, changed } = evaluateComputedNodes(computedNodes, stateForComputed, nestedKeys);
+    if (changed) {
+      computedValues = values;
+    }
+  }
+  function notifyStateListeners() {
+    const state = getCombinedState();
+    for (const listener of stateListeners) {
+      listener(state);
+    }
+  }
+  function notifyEventListeners(event) {
+    for (const listener of eventListeners) {
+      listener(event);
+    }
+  }
+  const forwardingEvents = /* @__PURE__ */ new Set();
+  let isForwardingToChildren = false;
+  function forwardEventToNestedChildren(event) {
+    if (nestedManagers.length === 0) return;
+    if (forwardingEvents.has(event.type)) return;
+    forwardingEvents.add(event.type);
+    isForwardingToChildren = true;
+    try {
+      for (const mgr of nestedManagers) {
+        if (mgr.kind === "single") {
+          const singleMgr = mgr;
+          if (singleMgr.instance) {
+            const childInternal = singleMgr.instance;
+            childInternal.__applyEvent(event, { skipEventLog: true });
+          }
+        } else if (mgr.kind === "array") {
+          const arrayMgr = mgr;
+          for (const [, entry] of arrayMgr.instances) {
+            const childInternal = entry.instance;
+            childInternal.__applyEvent(event, { skipEventLog: true });
+          }
+        } else if (mgr.kind === "map") {
+          const mapMgr = mgr;
+          for (const [, entry] of mapMgr.instances) {
+            const childInternal = entry.instance;
+            childInternal.__applyEvent(event, { skipEventLog: true });
+          }
+        }
+      }
+    } finally {
+      isForwardingToChildren = false;
+      forwardingEvents.delete(event.type);
+    }
+  }
+  function mwEvent(event, state) {
+    if (!config.middleware) return;
+    for (const mw of config.middleware) {
+      mw.onEvent?.(event, state);
+    }
+  }
+  function mwStateChange(prev, next) {
+    if (!config.middleware) return;
+    for (const mw of config.middleware) {
+      mw.onStateChange?.(prev, next);
+    }
+  }
+  function mwIntentStart(intent, payload) {
+    if (!config.middleware) return;
+    for (const mw of config.middleware) {
+      mw.onIntentStart?.(intent, payload);
+    }
+  }
+  function mwIntentEnd(intent, payload) {
+    if (!config.middleware) return;
+    for (const mw of config.middleware) {
+      mw.onIntentEnd?.(intent, payload);
+    }
+  }
+  function mwError(error, context) {
+    if (!config.middleware) return;
+    for (const mw of config.middleware) {
+      mw.onError?.(error, context);
+    }
+  }
+  function applyEvent(event, metaOrOptions) {
+    if (disposed) return;
+    const meta = metaOrOptions && "source" in metaOrOptions ? metaOrOptions : void 0;
+    const eventOptions = metaOrOptions && "skipEventLog" in metaOrOptions ? metaOrOptions : void 0;
+    if (!eventOptions?.skipEventLog) {
+      eventLog.push(event);
+    }
+    const handler = config.on?.[event.type];
+    if (handler) {
+      const prevState = getCombinedState();
+      const inputState = nestedManagers.length > 0 ? { ...rawState, ...getNestedStates() } : { ...rawState };
+      if (IS_DEV) Object.freeze(inputState);
+      const { type: _type, ...payload } = event;
+      const newState = meta ? handler(inputState, payload, meta) : handler(inputState, payload);
+      const changedKeys = /* @__PURE__ */ new Set();
+      for (const key of Object.keys(newState)) {
+        if (rawState[key] !== newState[key]) {
+          changedKeys.add(key);
+        }
+      }
+      rawState = newState;
+      invalidateCache();
+      if (nestedManagers.length > 0 && changedKeys.size > 0) {
+        syncNestedFromRawState(changedKeys);
+      }
+      if (config.computed && computedNodes.length > 0 && changedKeys.size > 0) {
+        const stateForComputed = nestedManagers.length > 0 ? { ...rawState, ...getNestedStates() } : rawState;
+        const { values } = evaluateComputedNodes(
+          computedNodes,
+          stateForComputed,
+          changedKeys
+        );
+        computedValues = values;
+        invalidateCache();
+      }
+      const nextState = getCombinedState();
+      stateSnapshots.push({ event, state: nextState });
+      mwEvent(event, nextState);
+      mwStateChange(prevState, nextState);
+      notifyEventListeners(event);
+      notifyStateListeners();
+    } else {
+      stateSnapshots.push({ event, state: getCombinedState() });
+      mwEvent(event, getCombinedState());
+      notifyEventListeners(event);
+    }
+    processRelay(event);
+    forwardEventToNestedChildren(event);
+  }
+  function processRelay(event) {
+    if (!config.relay || disposed) return;
+    const relayHandler = config.relay[event.type];
+    if (!relayHandler) return;
+    if (relayProcessing.has(event.type)) return;
+    relayDepth++;
+    if (relayDepth > MAX_RELAY_DEPTH) {
+      if (IS_DEV) {
+        console.error(
+          `[hurum] Relay depth limit exceeded (${MAX_RELAY_DEPTH}). Event: ${event.type}.`
+        );
+      }
+      relayDepth--;
+      return;
+    }
+    if (IS_DEV && relayDepth > 3) {
+      console.warn(`[hurum] Relay depth ${relayDepth} for event "${event.type}".`);
+    }
+    relayProcessing.add(event.type);
+    try {
+      const relayedEvents = relayHandler(event, rawState);
+      for (const relayedEvent of relayedEvents) {
+        applyEvent(relayedEvent);
+      }
+    } finally {
+      relayProcessing.delete(event.type);
+      relayDepth--;
+    }
+  }
+  function emit(event) {
+    if (disposed) return;
+    applyEvent(event);
+  }
+  const nestedExecutorIndex = /* @__PURE__ */ new Map();
+  function buildNestedExecutorIndex() {
+    for (const mgr of nestedManagers) {
+      if (mgr.kind === "single" && mgr.instance) {
+        const childDef = mgr.marker.store;
+        const childConfig = childDef.__config;
+        const childInternal = mgr.instance;
+        if (childConfig.executors) {
+          for (const executor of childConfig.executors) {
+            const command = getExecutorCommand(executor);
+            const cid = getCommandId(command);
+            nestedExecutorIndex.set(cid, childInternal);
+          }
+        }
+        const descendantCommands = childInternal.__getHandleableCommands();
+        for (const [cid, descendantStore] of descendantCommands) {
+          nestedExecutorIndex.set(cid, descendantStore);
+        }
+      }
+    }
+  }
+  function executeCommand(command, payload, signal) {
+    const commandId = getCommandId(command);
+    const executorFn = executorMap.get(commandId);
+    if (!executorFn) {
+      const childInstance = nestedExecutorIndex.get(commandId);
+      if (childInstance) {
+        return childInstance.__executeCommand(command, payload, signal);
+      }
+      return Promise.reject(new Error("[hurum] No executor registered for command"));
+    }
+    const context = {
+      deps,
+      emit,
+      getState: () => getCombinedState(),
+      signal,
+      scope
+    };
+    try {
+      const result = executorFn(payload, context);
+      return result instanceof Promise ? result : Promise.resolve();
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  }
+  function baseSend(intentOrPrepared, payload) {
+    if (disposed) {
+      throw new Error("[hurum] Cannot send intent to a disposed store");
+    }
+    let intent;
+    let resolvedPayload;
+    if (isPreparedIntent(intentOrPrepared)) {
+      intent = intentOrPrepared.intent;
+      resolvedPayload = intentOrPrepared.payload;
+    } else {
+      intent = intentOrPrepared;
+      resolvedPayload = payload;
+    }
+    const refSymbol = /* @__PURE__ */ Symbol("hurum/intent-ref");
+    const ref = { __intentRefBrand: refSymbol };
+    const controller = new AbortController();
+    runningControllers.set(refSymbol, controller);
+    runningCount++;
+    mwIntentStart(intent, resolvedPayload);
+    const execute = async () => {
+      try {
+        if (intent.mode === "sequential") {
+          for (const command of intent.commands) {
+            if (controller.signal.aborted) break;
+            await executeCommand(command, resolvedPayload, controller.signal);
+          }
+        } else if (intent.mode === "all") {
+          const promises = intent.commands.map((command) => {
+            const childCtrl = new AbortController();
+            controller.signal.addEventListener("abort", () => childCtrl.abort(), { once: true });
+            return executeCommand(command, resolvedPayload, childCtrl.signal);
+          });
+          try {
+            await Promise.all(promises);
+          } catch (error) {
+            controller.abort();
+            throw error;
+          }
+        } else if (intent.mode === "allSettled") {
+          const promises = intent.commands.map((command) => {
+            const childCtrl = new AbortController();
+            controller.signal.addEventListener("abort", () => childCtrl.abort(), { once: true });
+            return executeCommand(command, resolvedPayload, childCtrl.signal).catch((err) => {
+              mwError(err instanceof Error ? err : new Error(String(err)), { intent, command, payload: resolvedPayload });
+            });
+          });
+          await Promise.allSettled(promises);
+        }
+      } catch (error) {
+        mwError(error instanceof Error ? error : new Error(String(error)), { intent, payload: resolvedPayload });
+      } finally {
+        runningControllers.delete(refSymbol);
+        runningCount--;
+        mwIntentEnd(intent, resolvedPayload);
+      }
+    };
+    execute();
+    return ref;
+  }
+  function cancel(ref) {
+    const refSymbol = ref.__intentRefBrand;
+    const controller = runningControllers.get(refSymbol);
+    if (controller) {
+      controller.abort();
+      runningControllers.delete(refSymbol);
+      runningCount--;
+    }
+  }
+  function cancelAll() {
+    for (const [_sym, controller] of runningControllers) {
+      controller.abort();
+    }
+    runningControllers.clear();
+    runningCount = 0;
+  }
+  const __parentRootSend = options?.["__rootBaseSend"];
+  const __parentRootCancel = options?.["__rootCancel"];
+  const __parentRootCancelAll = options?.["__rootCancelAll"];
+  const rootBaseSend = __parentRootSend ?? baseSend;
+  const rootCancel = __parentRootCancel ?? cancel;
+  const rootCancelAll = __parentRootCancelAll ?? cancelAll;
+  function subscribe(cbOrType, cb) {
+    if (cbOrType === "events" && cb) {
+      eventListeners.add(cb);
+      return () => {
+        eventListeners.delete(cb);
+      };
+    }
+    if (typeof cbOrType === "function") {
+      stateListeners.add(cbOrType);
+      return () => {
+        stateListeners.delete(cbOrType);
+      };
+    }
+    throw new Error("[hurum] Invalid subscribe arguments");
+  }
+  function dispose() {
+    if (disposed) return;
+    disposed = true;
+    cancelAll();
+    for (const mgr of nestedManagers) {
+      if (mgr.kind === "single") {
+        if (mgr.unsub) mgr.unsub();
+        if (mgr.instance) mgr.instance.dispose();
+      } else {
+        for (const [, entry] of mgr.instances) {
+          entry.unsub();
+          entry.instance.dispose();
+        }
+        mgr.instances.clear();
+      }
+    }
+    stateListeners.clear();
+    eventListeners.clear();
+  }
+  function subscribeToNestedChild(childInstance, logToEventLog) {
+    const unsub = childInstance.subscribe(() => {
+      if (!disposed) {
+        const prev = getCombinedState();
+        recomputeFromNestedChange();
+        const next = getCombinedState();
+        mwStateChange(prev, next);
+        notifyStateListeners();
+      }
+    });
+    const unsubEvents = childInstance.subscribe("events", (event) => {
+      if (!disposed && !isForwardingToChildren) {
+        if (logToEventLog) eventLog.push(event);
+        mwEvent(event, getCombinedState());
+        notifyEventListeners(event);
+        processRelay(event);
+      }
+    });
+    return () => {
+      unsub();
+      unsubEvents();
+    };
+  }
+  function initNestedStores() {
+    for (const [key, marker] of Object.entries(nestedFields)) {
+      const storeDef = marker.store;
+      const childDepsFactory = config.childDepsMap?.[key];
+      if (marker.kind === "single") {
+        const mgr = {
+          kind: "single",
+          key,
+          marker,
+          instance: null,
+          unsub: null
+        };
+        const childDeps = childDepsFactory ? childDepsFactory(deps) : void 0;
+        const childCreateOpts = { deps: childDeps };
+        childCreateOpts["__rootBaseSend"] = rootBaseSend;
+        childCreateOpts["__rootCancel"] = rootCancel;
+        childCreateOpts["__rootCancelAll"] = rootCancelAll;
+        const childInstance = storeDef.create(childCreateOpts);
+        const childConfig = storeDef.__config;
+        childInstance.send = createSendProxy(rootBaseSend, childConfig.intents);
+        childInstance.cancel = rootCancel;
+        childInstance.cancelAll = rootCancelAll;
+        const unsubChild = subscribeToNestedChild(childInstance, false);
+        mgr.instance = childInstance;
+        mgr.unsub = unsubChild;
+        nestedManagers.push(mgr);
+        scope[key] = childInstance;
+      } else if (marker.kind === "array") {
+        const mgr = {
+          kind: "array",
+          key,
+          marker,
+          instances: /* @__PURE__ */ new Map()
+        };
+        nestedManagers.push(mgr);
+        const initialArray = options?.initialState?.[key];
+        if (Array.isArray(initialArray)) {
+          for (let i = 0; i < initialArray.length; i++) {
+            const item = initialArray[i];
+            const id = item?.id;
+            if (id == null) {
+              if (IS_DEV) {
+                console.warn(`[hurum] Nested.array item at index ${i} in "${key}" has no 'id' field. Skipping.`);
+              }
+              continue;
+            }
+            const instanceId = nextInstanceId();
+            const childDeps = childDepsFactory ? childDepsFactory(deps) : void 0;
+            const childInstance = storeDef.create({
+              initialState: item,
+              deps: childDeps
+            });
+            const meta = {
+              source: { instanceId, index: i, parentKey: key }
+            };
+            const unsubChild = subscribeToNestedChild(childInstance, true);
+            mgr.instances.set(String(id), {
+              instance: childInstance,
+              unsub: unsubChild
+            });
+            childInstance.__nestedMeta = meta;
+          }
+        }
+        const arrayScope = {
+          get(id) {
+            return mgr.instances.get(id)?.instance;
+          },
+          values() {
+            const arr = [];
+            for (const [, entry] of mgr.instances) {
+              arr.push(entry.instance);
+            }
+            return arr;
+          },
+          get size() {
+            return mgr.instances.size;
+          },
+          [Symbol.iterator]() {
+            const entries = mgr.instances.values();
+            return {
+              next() {
+                const result = entries.next();
+                if (result.done) return { done: true, value: void 0 };
+                return { done: false, value: result.value.instance };
+              }
+            };
+          }
+        };
+        scope[key] = arrayScope;
+      } else if (marker.kind === "map") {
+        const mgr = {
+          kind: "map",
+          key,
+          marker,
+          instances: /* @__PURE__ */ new Map()
+        };
+        nestedManagers.push(mgr);
+        const initialMap = options?.initialState?.[key];
+        if (initialMap && typeof initialMap === "object" && !Array.isArray(initialMap)) {
+          for (const [mapKey, mapValue] of Object.entries(initialMap)) {
+            const childDeps = childDepsFactory ? childDepsFactory(deps) : void 0;
+            const childInstance = storeDef.create({
+              initialState: mapValue,
+              deps: childDeps
+            });
+            const unsubChild = subscribeToNestedChild(childInstance, true);
+            mgr.instances.set(mapKey, {
+              instance: childInstance,
+              unsub: unsubChild
+            });
+          }
+        }
+        Object.defineProperty(scope, key, {
+          get: () => {
+            const map2 = /* @__PURE__ */ new Map();
+            for (const [k, entry] of mgr.instances) {
+              map2.set(k, entry.instance);
+            }
+            return map2;
+          },
+          enumerable: true,
+          configurable: true
+        });
+      }
+    }
+  }
+  function syncNestedArray(mgr, nextArray) {
+    if (!Array.isArray(nextArray)) return;
+    const storeDef = mgr.marker.store;
+    const childDepsFactory = config.childDepsMap?.[mgr.key];
+    const existingIds = new Set(mgr.instances.keys());
+    const nextIds = /* @__PURE__ */ new Set();
+    for (let i = 0; i < nextArray.length; i++) {
+      const item = nextArray[i];
+      const id = item?.id;
+      if (id == null) continue;
+      const idStr = String(id);
+      nextIds.add(idStr);
+      if (!existingIds.has(idStr)) {
+        const instanceId = nextInstanceId();
+        const childDeps = childDepsFactory ? childDepsFactory(deps) : void 0;
+        const childInstance = storeDef.create({
+          initialState: item,
+          deps: childDeps
+        });
+        const meta = {
+          source: { instanceId, index: i, parentKey: mgr.key }
+        };
+        childInstance.__nestedMeta = meta;
+        const unsubChild = subscribeToNestedChild(childInstance, true);
+        mgr.instances.set(idStr, {
+          instance: childInstance,
+          unsub: unsubChild
+        });
+      }
+    }
+    for (const id of existingIds) {
+      if (!nextIds.has(id)) {
+        const entry = mgr.instances.get(id);
+        entry.unsub();
+        entry.instance.dispose();
+        mgr.instances.delete(id);
+      }
+    }
+  }
+  function syncNestedMap(mgr, nextMap) {
+    if (!nextMap || typeof nextMap !== "object" || Array.isArray(nextMap)) return;
+    const storeDef = mgr.marker.store;
+    const childDepsFactory = config.childDepsMap?.[mgr.key];
+    const existingKeys = new Set(mgr.instances.keys());
+    const nextKeys = new Set(Object.keys(nextMap));
+    for (const key of nextKeys) {
+      if (!existingKeys.has(key)) {
+        const childDeps = childDepsFactory ? childDepsFactory(deps) : void 0;
+        const childInstance = storeDef.create({
+          initialState: nextMap[key],
+          deps: childDeps
+        });
+        const unsubChild = subscribeToNestedChild(childInstance, true);
+        mgr.instances.set(key, {
+          instance: childInstance,
+          unsub: unsubChild
+        });
+      }
+    }
+    for (const key of existingKeys) {
+      if (!nextKeys.has(key)) {
+        const entry = mgr.instances.get(key);
+        entry.unsub();
+        entry.instance.dispose();
+        mgr.instances.delete(key);
+      }
+    }
+  }
+  let syncingNested = false;
+  function syncNestedFromRawState(changedKeys) {
+    if (syncingNested) return;
+    syncingNested = true;
+    try {
+      for (const mgr of nestedManagers) {
+        if (mgr.kind !== "array" && mgr.kind !== "map") continue;
+        if (changedKeys && !changedKeys.has(mgr.key)) continue;
+        const currentRawValue = rawState[mgr.key];
+        if (currentRawValue !== void 0) {
+          if (mgr.kind === "array") {
+            syncNestedArray(mgr, currentRawValue);
+          } else if (mgr.kind === "map") {
+            syncNestedMap(mgr, currentRawValue);
+          }
+        }
+      }
+    } finally {
+      syncingNested = false;
+    }
+  }
+  initNestedStores();
+  buildNestedExecutorIndex();
+  if (nestedManagers.length > 0 && config.computed && computedNodes.length > 0) {
+    const combinedForInit = { ...rawState, ...getNestedStates() };
+    const freshNodes = initializeComputedNodes(
+      combinedForInit,
+      config.computed
+    );
+    computedNodes.length = 0;
+    computedNodes.push(...freshNodes);
+    computedValues = {};
+    for (const node of computedNodes) {
+      computedValues[node.name] = node.value;
+    }
+  }
+  const sendProxy = createSendProxy(baseSend, config.intents);
+  const instance = {
+    send: sendProxy,
+    cancel,
+    cancelAll,
+    getState: getCombinedState,
+    subscribe,
+    dispose,
+    selector(fn) {
+      return createSelector(
+        getCombinedState,
+        subscribe,
+        fn
+      );
+    },
+    scope,
+    // Internal — used by testing API and event forwarding
+    __eventLog: eventLog,
+    __stateSnapshots: stateSnapshots,
+    __runningCount: () => runningCount,
+    __rawState: () => rawState,
+    __applyEvent: (event, opts) => applyEvent(event, opts),
+    __executeCommand: executeCommand,
+    __getHandleableCommands: () => nestedExecutorIndex
+  };
+  Object.defineProperty(instance, STORE_INSTANCE_BRAND, {
+    value: true,
+    writable: false,
+    enumerable: false,
+    configurable: false
+  });
+  if (config.middleware) {
+    const storeRef = {
+      getState: () => getCombinedState(),
+      meta: {
+        computedKeys: computedNodes.map((n) => n.name),
+        nestedKeys: nestedManagers.map((m) => ({ key: m.key, kind: m.kind }))
+      }
+    };
+    for (const mw of config.middleware) {
+      mw.onAttach?.(storeRef);
+    }
+  }
+  return instance;
+}
+
+// src/middleware/logger.ts
+function logger(options) {
+  const filter = options?.filter;
+  return {
+    name: "logger",
+    onEvent: (event, state) => {
+      if (filter && !filter(event)) return;
+      console.group(`[Event] ${event.type}`);
+      console.log(event);
+      console.log("State:", state);
+      console.groupEnd();
+    },
+    onStateChange: (prev, next) => {
+      console.log("[State Change]", { prev, next });
+    },
+    onIntentStart: (intent, payload) => {
+      console.log("[Intent Start]", intent, payload);
+    },
+    onIntentEnd: (intent, payload) => {
+      console.log("[Intent End]", intent, payload);
+    },
+    onError: (error, context) => {
+      console.error("[Error]", error, context);
+    }
+  };
+}
+
+// src/middleware/persist.ts
+function pickKeys(state, keys) {
+  const result = {};
+  for (const key of keys) {
+    if (key in state) {
+      result[key] = state[key];
+    }
+  }
+  return result;
+}
+function persist(options) {
+  const {
+    key,
+    storage = typeof globalThis !== "undefined" && "localStorage" in globalThis ? globalThis.localStorage : void 0,
+    serialize = JSON.stringify,
+    deserialize = JSON.parse,
+    pick
+  } = options;
+  const middleware = {
+    name: "persist",
+    onStateChange: (_prev, next) => {
+      if (!storage) return;
+      try {
+        const toPersist = pick ? pickKeys(next, pick) : next;
+        storage.setItem(key, serialize(toPersist));
+      } catch {
+      }
+    }
+  };
+  function getPersistedState() {
+    if (!storage) return null;
+    try {
+      const raw = storage.getItem(key);
+      if (raw === null) return null;
+      return deserialize(raw);
+    } catch {
+      return null;
+    }
+  }
+  return { middleware, getPersistedState };
+}
+
+// src/middleware/devtools.ts
+function devtools(options) {
+  const name = options?.name ?? "Hurum Store";
+  let devToolsInstance = null;
+  let storeRef = null;
+  const middleware = {
+    name: "devtools",
+    onEvent: (event, state) => {
+      devToolsInstance?.send({ type: event.type, payload: event }, state);
+    },
+    onIntentStart: (_intent, payload) => {
+      devToolsInstance?.send(
+        { type: `[Intent] ${_intent.mode}`, payload },
+        storeRef?.getState() ?? {}
+      );
+    },
+    onError: (error, context) => {
+      devToolsInstance?.send(
+        { type: `[Error] ${error.message}`, payload: context },
+        storeRef?.getState() ?? {}
+      );
+    }
+  };
+  function connect(store) {
+    storeRef = store;
+    const extension = typeof globalThis !== "undefined" ? globalThis.__REDUX_DEVTOOLS_EXTENSION__ : void 0;
+    if (!extension) return;
+    devToolsInstance = extension.connect({ name });
+    devToolsInstance.init(store.getState());
+    devToolsInstance.subscribe((message) => {
+      if (message.type === "DISPATCH" && message.state) ;
+    });
+  }
+  return { middleware, connect };
+}
+
+// src/middleware/undo-redo.ts
+function undoRedo(options) {
+  const maxHistory = options?.maxHistory ?? 50;
+  const history = [];
+  let position = -1;
+  let tracking = true;
+  const middleware = {
+    name: "undo-redo",
+    onStateChange: (_prev, next) => {
+      if (!tracking) return;
+      if (position < history.length - 1) {
+        history.splice(position + 1);
+      }
+      history.push(structuredClone(next));
+      position = history.length - 1;
+      if (history.length > maxHistory) {
+        const excess = history.length - maxHistory;
+        history.splice(0, excess);
+        position -= excess;
+      }
+    }
+  };
+  function undo() {
+    if (position <= 0) return null;
+    tracking = false;
+    position--;
+    const state = structuredClone(history[position]);
+    tracking = true;
+    return state;
+  }
+  function redo() {
+    if (position >= history.length - 1) return null;
+    tracking = false;
+    position++;
+    const state = structuredClone(history[position]);
+    tracking = true;
+    return state;
+  }
+  function canUndo() {
+    return position > 0;
+  }
+  function canRedo() {
+    return position < history.length - 1;
+  }
+  function getHistory() {
+    return history;
+  }
+  function getPosition() {
+    return position;
+  }
+  return { middleware, undo, redo, canUndo, canRedo, getHistory, getPosition };
+}
+
+export { CommandExecutor, Event, Events, Intent, Intents, Nested, Store, devtools, isPreparedIntent, isSelector, isStoreDefinition, isStoreInstance, logger, persist, structuralEqual, undoRedo };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map