typetify 1.0.0 → 2.1.0

package/dist/index.mjs

@@ -1,6 +1,9 @@
+import { logic_exports } from './chunk-FT2EK4AM.mjs';
+import { narrowing_exports } from './chunk-CWHYQWNU.mjs';
+import { schema_exports } from './chunk-N6IUADIP.mjs';
 import { dx_exports } from './chunk-4NXETABV.mjs';
 export { assertNever, debug, deprecated, exhaustive, getLogLevel, invariant, log, measure, measureAsync, setLogLevel, todo } from './chunk-4NXETABV.mjs';
-export { brand, createMap, createSet, defineConst, defineEnum, defineTuple, narrow } from './chunk-JAOGY4JO.mjs';
+export { brand, createMap, createSet, defineConst, defineEnum, defineTuple, narrow } from './chunk-FEX5C4OH.mjs';
 import { string_exports } from './chunk-YOPAXITF.mjs';
 export { camelCase, capitalize, kebabCase, pascalCase, slugify, snakeCase, template, truncate, uncapitalize, words } from './chunk-YOPAXITF.mjs';
 import { fn_exports } from './chunk-ZE4FDBRI.mjs';
@@ -9,6 +12,7 @@ import { math_exports } from './chunk-JB6UXRKD.mjs';
 export { average, max, median, min, percentage, randomFloat, randomInt, round, sum } from './chunk-JB6UXRKD.mjs';
 import { result_exports } from './chunk-CN3GYRJN.mjs';
 export { andThen, fromNullable, isErr, isOk, mapErr, mapOption, mapResult, matchOption, matchResult, none, orElse, some, toNullable, unwrap, unwrapOption, unwrapOptionOr, unwrapOr } from './chunk-CN3GYRJN.mjs';
+import { iterator_exports } from './chunk-POD52NJ3.mjs';
 import { decorator_exports } from './chunk-TZEWREAC.mjs';
 export { Bind, Debounce, Deprecated, Frozen, Lazy, Log, Measure, Memoize, Retry, Sealed, Throttle, Validate } from './chunk-TZEWREAC.mjs';
 import { core_exports } from './chunk-QFR7DVAJ.mjs';
@@ -28,6 +32,809 @@ export { compose, constant, ifElse, match, pipe, tap, tryCatch, tryCatchAsync, u
 export { err, ok } from './chunk-FXWYPHA3.mjs';
 import { __export } from './chunk-J5LGTIGS.mjs';
 
+// src/reactive/index.ts
+var reactive_exports = {};
+__export(reactive_exports, {
+  batch: () => batch,
+  computed: () => computed,
+  createAutoUndoableState: () => createAutoUndoableState,
+  createUndoableState: () => createUndoableState,
+  effect: () => effect,
+  signal: () => signal
+});
+
+// src/reactive/signal.ts
+var currentComputed = null;
+function signal(initialValue) {
+  let value = initialValue;
+  const subscribers = /* @__PURE__ */ new Set();
+  const read = () => {
+    if (currentComputed) {
+      subscribers.add(currentComputed);
+    }
+    return value;
+  };
+  read.set = (newValue) => {
+    if (!Object.is(value, newValue)) {
+      value = newValue;
+      subscribers.forEach((fn) => fn(value));
+    }
+  };
+  read.update = (fn) => {
+    read.set(fn(value));
+  };
+  read.subscribe = (fn) => {
+    subscribers.add(fn);
+    return () => subscribers.delete(fn);
+  };
+  read.peek = () => value;
+  return read;
+}
+function computed(fn) {
+  const internalSignal = signal(void 0);
+  const recompute = () => {
+    const prevComputed = currentComputed;
+    currentComputed = recompute;
+    try {
+      internalSignal.set(fn());
+    } finally {
+      currentComputed = prevComputed;
+    }
+  };
+  recompute();
+  const read = () => internalSignal();
+  read.subscribe = internalSignal.subscribe;
+  read.peek = internalSignal.peek;
+  return read;
+}
+function effect(fn) {
+  let cleanup;
+  const run = () => {
+    if (cleanup) cleanup();
+    const prevComputed = currentComputed;
+    currentComputed = run;
+    try {
+      cleanup = fn();
+    } finally {
+      currentComputed = prevComputed;
+    }
+  };
+  run();
+  return () => {
+    if (cleanup) cleanup();
+  };
+}
+var batchDepth = 0;
+var pendingEffects = /* @__PURE__ */ new Set();
+function batch(fn) {
+  batchDepth++;
+  try {
+    fn();
+  } finally {
+    batchDepth--;
+    if (batchDepth === 0) {
+      const effects = pendingEffects;
+      pendingEffects = /* @__PURE__ */ new Set();
+      effects.forEach((effect2) => effect2());
+    }
+  }
+}
+
+// src/reactive/undoable.ts
+function createUndoableState(initialValue, options = {}) {
+  const { maxHistory = 100 } = options;
+  const value = signal(initialValue);
+  const history = [initialValue];
+  let currentIndex = 0;
+  const canUndo = () => currentIndex > 0;
+  const canRedo = () => currentIndex < history.length - 1;
+  const undo = () => {
+    if (canUndo()) {
+      currentIndex--;
+      value.set(structuredClone(history[currentIndex]));
+    }
+  };
+  const redo = () => {
+    if (canRedo()) {
+      currentIndex++;
+      value.set(structuredClone(history[currentIndex]));
+    }
+  };
+  const commit = () => {
+    const currentValue = value();
+    if (currentIndex < history.length && JSON.stringify(history[currentIndex]) === JSON.stringify(currentValue)) {
+      return;
+    }
+    history.splice(currentIndex + 1);
+    history.push(structuredClone(currentValue));
+    currentIndex = history.length - 1;
+    if (history.length > maxHistory) {
+      history.shift();
+      currentIndex--;
+    }
+  };
+  const clearHistory = () => {
+    const currentValue = value();
+    history.length = 0;
+    history.push(structuredClone(currentValue));
+    currentIndex = 0;
+  };
+  const historyLength = () => history.length;
+  return {
+    value,
+    undo,
+    redo,
+    canUndo,
+    canRedo,
+    clearHistory,
+    historyLength,
+    commit
+  };
+}
+function createAutoUndoableState(initialValue, options = {}) {
+  const undoable = createUndoableState(initialValue, options);
+  const read = () => undoable.value();
+  read.set = (newValue) => {
+    undoable.value.set(newValue);
+    undoable.commit();
+  };
+  read.update = (fn) => {
+    read.set(fn(undoable.value()));
+  };
+  read.undo = undoable.undo;
+  read.redo = undoable.redo;
+  read.canUndo = undoable.canUndo;
+  read.canRedo = undoable.canRedo;
+  return read;
+}
+
+// src/cache/index.ts
+var cache_exports = {};
+__export(cache_exports, {
+  memoize: () => memoize2,
+  smartCache: () => smartCache
+});
+
+// src/cache/smartCache.ts
+function parseTTL(ttl) {
+  if (typeof ttl === "number") return ttl;
+  const match2 = ttl.match(/^(\d+)(ms|s|m|h|d)$/);
+  if (!match2) throw new Error(`Invalid TTL format: ${ttl}`);
+  const [, value, unit] = match2;
+  const num = parseInt(value, 10);
+  switch (unit) {
+    case "ms":
+      return num;
+    case "s":
+      return num * 1e3;
+    case "m":
+      return num * 60 * 1e3;
+    case "h":
+      return num * 60 * 60 * 1e3;
+    case "d":
+      return num * 24 * 60 * 60 * 1e3;
+    default:
+      return num;
+  }
+}
+function smartCache(fn, options = {}) {
+  const {
+    ttl = Infinity,
+    maxSize = 1e3,
+    key = (...args) => JSON.stringify(args),
+    onHit,
+    onMiss
+  } = options;
+  const ttlMs = parseTTL(ttl);
+  const cache = /* @__PURE__ */ new Map();
+  const getKey = (...args) => key(...args);
+  const isExpired = (entry) => {
+    return Date.now() > entry.expiresAt;
+  };
+  const evictOldest = () => {
+    if (cache.size >= maxSize) {
+      const firstKey = cache.keys().next().value;
+      if (firstKey) cache.delete(firstKey);
+    }
+  };
+  const cached = async (...args) => {
+    const cacheKey = getKey(...args);
+    const entry = cache.get(cacheKey);
+    if (entry && !isExpired(entry)) {
+      onHit?.(cacheKey, entry.value);
+      return entry.value;
+    }
+    onMiss?.(cacheKey);
+    if (entry) cache.delete(cacheKey);
+    evictOldest();
+    const value = await fn(...args);
+    cache.set(cacheKey, {
+      value,
+      expiresAt: Date.now() + ttlMs
+    });
+    return value;
+  };
+  cached.invalidate = (...args) => {
+    const cacheKey = getKey(...args);
+    cache.delete(cacheKey);
+  };
+  cached.invalidateAll = () => {
+    cache.clear();
+  };
+  cached.clear = cached.invalidateAll;
+  cached.has = (...args) => {
+    const cacheKey = getKey(...args);
+    const entry = cache.get(cacheKey);
+    return entry !== void 0 && !isExpired(entry);
+  };
+  cached.size = () => cache.size;
+  return cached;
+}
+function memoize2(fn) {
+  const cache = /* @__PURE__ */ new Map();
+  return (...args) => {
+    const key = JSON.stringify(args);
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    const result = fn(...args);
+    cache.set(key, result);
+    return result;
+  };
+}
+
+// src/event/index.ts
+var event_exports = {};
+__export(event_exports, {
+  createEventBus: () => createEventBus,
+  createTypedEmitter: () => createTypedEmitter
+});
+
+// src/event/eventBus.ts
+function createEventBus() {
+  const handlers = /* @__PURE__ */ new Map();
+  const getHandlers = (event) => {
+    if (!handlers.has(event)) {
+      handlers.set(event, /* @__PURE__ */ new Set());
+    }
+    return handlers.get(event);
+  };
+  return {
+    on(event, handler) {
+      const eventHandlers = getHandlers(event);
+      eventHandlers.add(handler);
+      return () => eventHandlers.delete(handler);
+    },
+    once(event, handler) {
+      const wrappedHandler = (data) => {
+        handler(data);
+        getHandlers(event).delete(wrappedHandler);
+      };
+      return this.on(event, wrappedHandler);
+    },
+    emit(event, data) {
+      const eventHandlers = getHandlers(event);
+      eventHandlers.forEach((handler) => handler(data));
+    },
+    off(event) {
+      handlers.delete(event);
+    },
+    clear() {
+      handlers.clear();
+    },
+    listenerCount(event) {
+      return getHandlers(event).size;
+    }
+  };
+}
+function createTypedEmitter() {
+  return createEventBus();
+}
+
+// src/pipeline/index.ts
+var pipeline_exports = {};
+__export(pipeline_exports, {
+  compose: () => compose2,
+  createMiddleware: () => createMiddleware,
+  flow: () => flow,
+  pipe: () => pipe2,
+  pipeAsync: () => pipeAsync
+});
+
+// src/pipeline/pipe.ts
+function pipe2(value, ...fns) {
+  return fns.reduce((acc, fn) => fn(acc), value);
+}
+async function pipeAsync(value, ...fns) {
+  let result = value;
+  for (const fn of fns) {
+    result = await fn(result);
+  }
+  return result;
+}
+function flow(...fns) {
+  return (value) => fns.reduce((acc, fn) => fn(acc), value);
+}
+
+// src/pipeline/middleware.ts
+function createMiddleware() {
+  const middlewares = [];
+  const pipeline = {
+    use(middleware) {
+      middlewares.push(middleware);
+      return pipeline;
+    },
+    async execute(ctx) {
+      let index = 0;
+      const next = async () => {
+        if (index < middlewares.length) {
+          const middleware = middlewares[index++];
+          await middleware(ctx, next);
+        }
+      };
+      await next();
+    },
+    handler() {
+      return (ctx) => pipeline.execute(ctx);
+    }
+  };
+  return pipeline;
+}
+function compose2(...middlewares) {
+  return async (ctx, next) => {
+    let index = 0;
+    const dispatch = async () => {
+      if (index < middlewares.length) {
+        const middleware = middlewares[index++];
+        await middleware(ctx, dispatch);
+      } else {
+        await next();
+      }
+    };
+    await dispatch();
+  };
+}
+
+// src/di/index.ts
+var di_exports = {};
+__export(di_exports, {
+  createContainer: () => createContainer,
+  createTypedContainer: () => createTypedContainer
+});
+
+// src/di/container.ts
+function createContainer(parent) {
+  const services = /* @__PURE__ */ new Map();
+  const container = {
+    register(key, factory) {
+      services.set(key, { factory, singleton: false });
+      return container;
+    },
+    singleton(key, factory) {
+      services.set(key, { factory, singleton: true });
+      return container;
+    },
+    constant(key, value) {
+      services.set(key, {
+        factory: () => value,
+        singleton: true,
+        instance: value
+      });
+      return container;
+    },
+    resolve(key) {
+      const descriptor = services.get(key);
+      if (!descriptor) {
+        if (parent) {
+          return parent.resolve(key);
+        }
+        throw new Error(`Service not found: ${String(key)}`);
+      }
+      if (descriptor.singleton) {
+        if (descriptor.instance === void 0) {
+          descriptor.instance = descriptor.factory(container);
+        }
+        return descriptor.instance;
+      }
+      return descriptor.factory(container);
+    },
+    has(key) {
+      return services.has(key) || (parent?.has(key) ?? false);
+    },
+    createChild() {
+      return createContainer(container);
+    }
+  };
+  return container;
+}
+function createTypedContainer() {
+  const container = createContainer();
+  return {
+    register(key, factory) {
+      container.register(key, factory);
+      return this;
+    },
+    singleton(key, factory) {
+      container.singleton(key, factory);
+      return this;
+    },
+    constant(key, value) {
+      container.constant(key, value);
+      return this;
+    },
+    resolve(key) {
+      return container.resolve(key);
+    },
+    has(key) {
+      return container.has(key);
+    }
+  };
+}
+
+// src/env/index.ts
+var env_exports = {};
+__export(env_exports, {
+  createEnv: () => createEnv,
+  env: () => env
+});
+
+// src/env/env.ts
+var env = {
+  /**
+   * String environment variable
+   */
+  string(options) {
+    return {
+      _type: "",
+      _parse: (value) => {
+        if (value === void 0) {
+          if (options?.default !== void 0) return options.default;
+          throw new Error("Required environment variable is missing");
+        }
+        return value;
+      },
+      _default: options?.default
+    };
+  },
+  /**
+   * Number environment variable
+   */
+  number(options) {
+    return {
+      _type: 0,
+      _parse: (value) => {
+        if (value === void 0) {
+          if (options?.default !== void 0) return options.default;
+          throw new Error("Required environment variable is missing");
+        }
+        const num = Number(value);
+        if (isNaN(num)) throw new Error(`Invalid number: ${value}`);
+        return num;
+      },
+      _default: options?.default
+    };
+  },
+  /**
+   * Boolean environment variable
+   */
+  boolean(options) {
+    return {
+      _type: false,
+      _parse: (value) => {
+        if (value === void 0) {
+          if (options?.default !== void 0) return options.default;
+          throw new Error("Required environment variable is missing");
+        }
+        return value === "true" || value === "1" || value === "yes";
+      },
+      _default: options?.default
+    };
+  },
+  /**
+   * Enum environment variable
+   */
+  enum(values, options) {
+    return {
+      _type: "",
+      _parse: (value) => {
+        if (value === void 0) {
+          if (options?.default !== void 0) return options.default;
+          throw new Error("Required environment variable is missing");
+        }
+        if (!values.includes(value)) {
+          throw new Error(`Invalid value: ${value}. Expected one of: ${values.join(", ")}`);
+        }
+        return value;
+      },
+      _default: options?.default
+    };
+  },
+  /**
+   * URL environment variable
+   */
+  url(options) {
+    return {
+      _type: "",
+      _parse: (value) => {
+        if (value === void 0) {
+          if (options?.default !== void 0) return options.default;
+          throw new Error("Required environment variable is missing");
+        }
+        try {
+          new URL(value);
+          return value;
+        } catch {
+          throw new Error(`Invalid URL: ${value}`);
+        }
+      },
+      _default: options?.default
+    };
+  },
+  /**
+   * JSON environment variable
+   */
+  json(options) {
+    return {
+      _type: {},
+      _parse: (value) => {
+        if (value === void 0) {
+          if (options?.default !== void 0) return options.default;
+          throw new Error("Required environment variable is missing");
+        }
+        try {
+          return JSON.parse(value);
+        } catch {
+          throw new Error(`Invalid JSON: ${value}`);
+        }
+      },
+      _default: options?.default
+    };
+  },
+  /**
+   * Array environment variable (comma-separated)
+   */
+  array(options) {
+    const separator = options?.separator ?? ",";
+    return {
+      _type: [],
+      _parse: (value) => {
+        if (value === void 0) {
+          if (options?.default !== void 0) return options.default;
+          throw new Error("Required environment variable is missing");
+        }
+        return value.split(separator).map((s) => s.trim());
+      },
+      _default: options?.default
+    };
+  }
+};
+function createEnv(schema, envSource = typeof process !== "undefined" ? process.env : {}) {
+  const result = {};
+  const errors = [];
+  for (const [key, varDef] of Object.entries(schema)) {
+    try {
+      result[key] = varDef._parse(envSource[key]);
+    } catch (error) {
+      errors.push(`${key}: ${error.message}`);
+    }
+  }
+  if (errors.length > 0) {
+    throw new Error(`Environment validation failed:
+${errors.join("\n")}`);
+  }
+  return result;
+}
+
+// src/router/index.ts
+var router_exports = {};
+__export(router_exports, {
+  createRouter: () => createRouter,
+  route: () => route
+});
+
+// src/router/router.ts
+function route(path, params) {
+  const paramNames = (path.match(/:(\w+)/g) || []).map((p) => p.slice(1));
+  const paramDefs = params || {};
+  const build = (values) => {
+    let result = path;
+    for (const name of paramNames) {
+      const value = values[name];
+      result = result.replace(`:${name}`, String(value));
+    }
+    return result;
+  };
+  const match2 = (testPath) => {
+    const pattern = path.replace(/:(\w+)/g, "([^/]+)");
+    const regex = new RegExp(`^${pattern}$`);
+    const matches = testPath.match(regex);
+    if (!matches) return null;
+    const result = {};
+    paramNames.forEach((name, index) => {
+      const value = matches[index + 1];
+      const type = paramDefs[name];
+      if (type === "number") {
+        result[name] = Number(value);
+      } else if (type === "boolean") {
+        result[name] = value === "true";
+      } else {
+        result[name] = value;
+      }
+    });
+    return result;
+  };
+  return { path, params: paramDefs, build, match: match2 };
+}
+function createRouter(routes) {
+  return {
+    routes,
+    navigate(name, params) {
+      const routeDef = routes[name];
+      if (!routeDef) throw new Error(`Route not found: ${String(name)}`);
+      return routeDef.build(params);
+    },
+    match(path) {
+      for (const [name, routeDef] of Object.entries(routes)) {
+        const params = routeDef.match(path);
+        if (params) {
+          return { name, params };
+        }
+      }
+      return null;
+    }
+  };
+}
+
+// src/form/index.ts
+var form_exports = {};
+__export(form_exports, {
+  createForm: () => createForm,
+  field: () => field
+});
+
+// src/form/form.ts
+function field(initial, validate) {
+  return { initial, validate };
+}
+function createForm(config) {
+  const fieldEntries = Object.entries(config);
+  const fields = {};
+  for (const [key, fieldConfig] of fieldEntries) {
+    const value = signal(fieldConfig.initial);
+    const error = signal(null);
+    const touched = signal(false);
+    const dirty = signal(false);
+    const initialValue = fieldConfig.initial;
+    value.subscribe((v) => {
+      dirty.set(v !== initialValue);
+      if (fieldConfig.validate) {
+        error.set(fieldConfig.validate(v));
+      }
+    });
+    fields[key] = { value, error, touched, dirty };
+  }
+  const values = () => {
+    const result = {};
+    for (const key of Object.keys(fields)) {
+      result[key] = fields[key].value();
+    }
+    return result;
+  };
+  const errors = () => {
+    const result = {};
+    for (const key of Object.keys(fields)) {
+      const err2 = fields[key].error();
+      if (err2) result[key] = err2;
+    }
+    return result;
+  };
+  const isValid = () => {
+    return Object.keys(fields).every(
+      (key) => fields[key].error() === null
+    );
+  };
+  const isDirty = () => {
+    return Object.keys(fields).some(
+      (key) => fields[key].dirty()
+    );
+  };
+  const isTouched = () => {
+    return Object.keys(fields).some(
+      (key) => fields[key].touched()
+    );
+  };
+  const reset = () => {
+    for (const [key, fieldConfig] of fieldEntries) {
+      fields[key].value.set(fieldConfig.initial);
+      fields[key].error.set(null);
+      fields[key].touched.set(false);
+      fields[key].dirty.set(false);
+    }
+  };
+  const validate = () => {
+    for (const [key, fieldConfig] of fieldEntries) {
+      if (fieldConfig.validate) {
+        const err2 = fieldConfig.validate(fields[key].value());
+        fields[key].error.set(err2);
+      }
+      fields[key].touched.set(true);
+    }
+    return isValid();
+  };
+  const submit = async (handler) => {
+    if (validate()) {
+      await handler(values());
+    }
+  };
+  return {
+    fields,
+    values,
+    errors,
+    isValid,
+    isDirty,
+    isTouched,
+    reset,
+    validate,
+    submit
+  };
+}
+
+// src/feature/index.ts
+var feature_exports = {};
+__export(feature_exports, {
+  createFeatureFlags: () => createFeatureFlags,
+  flag: () => flag
+});
+
+// src/feature/featureFlags.ts
+var flag = {
+  boolean(defaultValue = false) {
+    return { type: "boolean", default: defaultValue };
+  },
+  string(defaultValue = "") {
+    return { type: "string", default: defaultValue };
+  },
+  number(defaultValue = 0) {
+    return { type: "number", default: defaultValue };
+  }
+};
+function createFeatureFlags(schema) {
+  const values = {};
+  for (const [key, config] of Object.entries(schema)) {
+    values[key] = config.default;
+  }
+  return {
+    is(key) {
+      const config = schema[key];
+      if (config?.type !== "boolean") {
+        throw new Error(`Flag '${String(key)}' is not a boolean flag`);
+      }
+      return values[key];
+    },
+    get(key) {
+      return values[key];
+    },
+    set(key, value) {
+      values[key] = value;
+    },
+    all() {
+      return { ...values };
+    },
+    reset() {
+      for (const [key, config] of Object.entries(schema)) {
+        values[key] = config.default;
+      }
+    },
+    load(flags) {
+      for (const [key, value] of Object.entries(flags)) {
+        if (key in schema && value !== void 0) {
+          values[key] = value;
+        }
+      }
+    }
+  };
+}
+
 // src/array/index.ts
 var array_exports = {};
 __export(array_exports, {
@@ -461,10 +1268,10 @@ function sortedUniqBy(array, iteratee) {
   const result = [array[0]];
   let lastComputed = iteratee(array[0]);
   for (let i = 1; i < array.length; i++) {
-    const computed = iteratee(array[i]);
-    if (computed !== lastComputed) {
+    const computed2 = iteratee(array[i]);
+    if (computed2 !== lastComputed) {
       result.push(array[i]);
-      lastComputed = computed;
+      lastComputed = computed2;
     }
   }
   return result;
@@ -510,9 +1317,9 @@ function unionBy(iteratee, ...arrays) {
   const result = [];
   for (const array of arrays) {
     for (const item of array) {
-      const computed = iteratee(item);
-      if (!seen.has(computed)) {
-        seen.add(computed);
+      const computed2 = iteratee(item);
+      if (!seen.has(computed2)) {
+        seen.add(computed2);
         result.push(item);
       }
     }
@@ -539,9 +1346,9 @@ function uniqBy(array, iteratee) {
   const seen = /* @__PURE__ */ new Set();
   const result = [];
   for (const item of array) {
-    const computed = iteratee(item);
-    if (!seen.has(computed)) {
-      seen.add(computed);
+    const computed2 = iteratee(item);
+    if (!seen.has(computed2)) {
+      seen.add(computed2);
       result.push(item);
     }
   }
@@ -605,14 +1412,14 @@ function xorBy(iteratee, ...arrays) {
   for (const array of arrays) {
     const seen = /* @__PURE__ */ new Set();
     for (const item of array) {
-      const computed = iteratee(item);
-      if (!seen.has(computed)) {
-        seen.add(computed);
-        const existing = counts.get(computed);
+      const computed2 = iteratee(item);
+      if (!seen.has(computed2)) {
+        seen.add(computed2);
+        const existing = counts.get(computed2);
         if (existing) {
           existing.count++;
         } else {
-          counts.set(computed, { count: 1, item });
+          counts.set(computed2, { count: 1, item });
         }
       }
     }
@@ -716,10 +1523,24 @@ var _ = {
   ...math_exports,
   ...result_exports,
   ...decorator_exports,
-  ...array_exports
+  ...array_exports,
+  // typed: excluded due to unique symbol export limitations - use direct imports
+  ...logic_exports,
+  ...iterator_exports,
+  ...narrowing_exports,
+  ...schema_exports,
+  ...reactive_exports,
+  ...cache_exports,
+  ...event_exports,
+  ...pipeline_exports,
+  ...di_exports,
+  ...env_exports,
+  ...router_exports,
+  ...form_exports,
+  ...feature_exports
 };
 var src_default = _;
 
-export { _, concat, src_default as default, differenceBy, differenceWith, dropRight, dropRightWhile, fill, findIndex, findLastIndex, flattenDeep, flattenDepth, fromPairs, indexOf, intersectionBy, intersectionWith, join, lastIndexOf, nth, pull, pullAll, pullAllBy, pullAllWith, pullAt, remove, reverse, slice, sortedIndex, sortedIndexBy, sortedIndexOf, sortedLastIndex, sortedLastIndexBy, sortedLastIndexOf, sortedUniq, sortedUniqBy, takeRight, takeRightWhile, union, unionBy, unionWith, uniqBy, uniqWith, unzipWith, without, xor, xorBy, xorWith, zipObject, zipObjectDeep, zipWith };
+export { _, batch, compose2 as composeMiddleware, computed, concat, createAutoUndoableState, createContainer, createEnv, createEventBus, createFeatureFlags, createForm, createMiddleware, createRouter, createTypedContainer, createTypedEmitter, createUndoableState, src_default as default, differenceBy, differenceWith, dropRight, dropRightWhile, effect, env, field, fill, findIndex, findLastIndex, flag, flattenDeep, flattenDepth, flow, fromPairs, indexOf, intersectionBy, intersectionWith, join, lastIndexOf, nth, pipeAsync, pipe2 as pipeValue, pull, pullAll, pullAllBy, pullAllWith, pullAt, remove, reverse, route, signal, slice, smartCache, memoize2 as smartMemoize, sortedIndex, sortedIndexBy, sortedIndexOf, sortedLastIndex, sortedLastIndexBy, sortedLastIndexOf, sortedUniq, sortedUniqBy, takeRight, takeRightWhile, union, unionBy, unionWith, uniqBy, uniqWith, unzipWith, without, xor, xorBy, xorWith, zipObject, zipObjectDeep, zipWith };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map