eslint-plugin-react-hooks 7.0.0-canary-93f85932-20251016 → 7.0.0-canary-1324e1bb-20251016

package/cjs/eslint-plugin-react-hooks.development.js

@@ -16,8 +16,8 @@ if (process.env.NODE_ENV !== "production") {
 
 var core$1 = require('@babel/core');
 var BabelParser = require('@babel/parser');
-var zod = require('zod');
-var zodValidationError = require('zod-validation-error');
+var v4 = require('zod/v4');
+var v4$1 = require('zod-validation-error/v4');
 var crypto = require('crypto');
 var HermesParser = require('hermes-parser');
 var util = require('util');
@@ -18303,7 +18303,7 @@ function getRuleForCategoryImpl(category) {
                 category,
                 severity: ErrorSeverity.Error,
                 name: 'void-use-memo',
-                description: 'Validates that useMemos always return a value. See [`useMemo()` docs](https://react.dev/reference/react/useMemo) for more information.',
+                description: 'Validates that useMemos always return a value and that the result of the useMemo is used by the component/hook. See [`useMemo()` docs](https://react.dev/reference/react/useMemo) for more information.',
                 preset: LintRulePreset.RecommendedLatest,
             };
         }
@@ -18735,7 +18735,7 @@ var ValueKind;
     ValueKind["Mutable"] = "mutable";
     ValueKind["Context"] = "context";
 })(ValueKind || (ValueKind = {}));
-const ValueKindSchema = zod.z.enum([
+const ValueKindSchema = v4.z.enum([
     ValueKind.MaybeFrozen,
     ValueKind.Frozen,
     ValueKind.Primitive,
@@ -18743,7 +18743,7 @@ const ValueKindSchema = zod.z.enum([
     ValueKind.Mutable,
     ValueKind.Context,
 ]);
-const ValueReasonSchema = zod.z.enum([
+const ValueReasonSchema = v4.z.enum([
     ValueReason.Context,
     ValueReason.Effect,
     ValueReason.Global,
@@ -18767,7 +18767,7 @@ var Effect;
     Effect["Mutate"] = "mutate";
     Effect["Store"] = "store";
 })(Effect || (Effect = {}));
-const EffectSchema = zod.z.enum([
+const EffectSchema = v4.z.enum([
     Effect.Read,
     Effect.Mutate,
     Effect.ConditionallyMutate,
@@ -31322,85 +31322,85 @@ function getReanimatedModuleType(registry) {
     return addObject(registry, null, reanimatedType);
 }
 
-const ObjectPropertiesSchema = zod.z
-    .record(zod.z.string(), zod.z.lazy(() => TypeSchema))
+const ObjectPropertiesSchema = v4.z
+    .record(v4.z.string(), v4.z.lazy(() => TypeSchema))
     .refine(record => {
     return Object.keys(record).every(key => key === '*' || key === 'default' || libExports$1.isValidIdentifier(key));
 }, 'Expected all "object" property names to be valid identifier, `*` to match any property, of `default` to define a module default export');
-const ObjectTypeSchema = zod.z.object({
-    kind: zod.z.literal('object'),
+const ObjectTypeSchema = v4.z.object({
+    kind: v4.z.literal('object'),
     properties: ObjectPropertiesSchema.nullable(),
 });
-const LifetimeIdSchema = zod.z.string().refine(id => id.startsWith('@'), {
+const LifetimeIdSchema = v4.z.string().refine(id => id.startsWith('@'), {
     message: "Placeholder names must start with '@'",
 });
-const FreezeEffectSchema = zod.z.object({
-    kind: zod.z.literal('Freeze'),
+const FreezeEffectSchema = v4.z.object({
+    kind: v4.z.literal('Freeze'),
     value: LifetimeIdSchema,
     reason: ValueReasonSchema,
 });
-const MutateEffectSchema = zod.z.object({
-    kind: zod.z.literal('Mutate'),
+const MutateEffectSchema = v4.z.object({
+    kind: v4.z.literal('Mutate'),
     value: LifetimeIdSchema,
 });
-const MutateTransitiveConditionallySchema = zod.z.object({
-    kind: zod.z.literal('MutateTransitiveConditionally'),
+const MutateTransitiveConditionallySchema = v4.z.object({
+    kind: v4.z.literal('MutateTransitiveConditionally'),
     value: LifetimeIdSchema,
 });
-const CreateEffectSchema = zod.z.object({
-    kind: zod.z.literal('Create'),
+const CreateEffectSchema = v4.z.object({
+    kind: v4.z.literal('Create'),
     into: LifetimeIdSchema,
     value: ValueKindSchema,
     reason: ValueReasonSchema,
 });
-const AssignEffectSchema = zod.z.object({
-    kind: zod.z.literal('Assign'),
+const AssignEffectSchema = v4.z.object({
+    kind: v4.z.literal('Assign'),
     from: LifetimeIdSchema,
     into: LifetimeIdSchema,
 });
-const AliasEffectSchema = zod.z.object({
-    kind: zod.z.literal('Alias'),
+const AliasEffectSchema = v4.z.object({
+    kind: v4.z.literal('Alias'),
     from: LifetimeIdSchema,
     into: LifetimeIdSchema,
 });
-const ImmutableCaptureEffectSchema = zod.z.object({
-    kind: zod.z.literal('ImmutableCapture'),
+const ImmutableCaptureEffectSchema = v4.z.object({
+    kind: v4.z.literal('ImmutableCapture'),
     from: LifetimeIdSchema,
     into: LifetimeIdSchema,
 });
-const CaptureEffectSchema = zod.z.object({
-    kind: zod.z.literal('Capture'),
+const CaptureEffectSchema = v4.z.object({
+    kind: v4.z.literal('Capture'),
     from: LifetimeIdSchema,
     into: LifetimeIdSchema,
 });
-const CreateFromEffectSchema = zod.z.object({
-    kind: zod.z.literal('CreateFrom'),
+const CreateFromEffectSchema = v4.z.object({
+    kind: v4.z.literal('CreateFrom'),
     from: LifetimeIdSchema,
     into: LifetimeIdSchema,
 });
-const ApplyArgSchema = zod.z.union([
+const ApplyArgSchema = v4.z.union([
     LifetimeIdSchema,
-    zod.z.object({
-        kind: zod.z.literal('Spread'),
+    v4.z.object({
+        kind: v4.z.literal('Spread'),
         place: LifetimeIdSchema,
     }),
-    zod.z.object({
-        kind: zod.z.literal('Hole'),
+    v4.z.object({
+        kind: v4.z.literal('Hole'),
     }),
 ]);
-const ApplyEffectSchema = zod.z.object({
-    kind: zod.z.literal('Apply'),
+const ApplyEffectSchema = v4.z.object({
+    kind: v4.z.literal('Apply'),
     receiver: LifetimeIdSchema,
     function: LifetimeIdSchema,
-    mutatesFunction: zod.z.boolean(),
-    args: zod.z.array(ApplyArgSchema),
+    mutatesFunction: v4.z.boolean(),
+    args: v4.z.array(ApplyArgSchema),
     into: LifetimeIdSchema,
 });
-const ImpureEffectSchema = zod.z.object({
-    kind: zod.z.literal('Impure'),
+const ImpureEffectSchema = v4.z.object({
+    kind: v4.z.literal('Impure'),
     place: LifetimeIdSchema,
 });
-const AliasingEffectSchema = zod.z.union([
+const AliasingEffectSchema = v4.z.union([
     FreezeEffectSchema,
     CreateEffectSchema,
     CreateFromEffectSchema,
@@ -31413,50 +31413,50 @@ const AliasingEffectSchema = zod.z.union([
     MutateTransitiveConditionallySchema,
     ApplyEffectSchema,
 ]);
-const AliasingSignatureSchema = zod.z.object({
+const AliasingSignatureSchema = v4.z.object({
     receiver: LifetimeIdSchema,
-    params: zod.z.array(LifetimeIdSchema),
+    params: v4.z.array(LifetimeIdSchema),
     rest: LifetimeIdSchema.nullable(),
     returns: LifetimeIdSchema,
-    effects: zod.z.array(AliasingEffectSchema),
-    temporaries: zod.z.array(LifetimeIdSchema),
+    effects: v4.z.array(AliasingEffectSchema),
+    temporaries: v4.z.array(LifetimeIdSchema),
 });
-const FunctionTypeSchema = zod.z.object({
-    kind: zod.z.literal('function'),
-    positionalParams: zod.z.array(EffectSchema),
+const FunctionTypeSchema = v4.z.object({
+    kind: v4.z.literal('function'),
+    positionalParams: v4.z.array(EffectSchema),
     restParam: EffectSchema.nullable(),
     calleeEffect: EffectSchema,
-    returnType: zod.z.lazy(() => TypeSchema),
+    returnType: v4.z.lazy(() => TypeSchema),
     returnValueKind: ValueKindSchema,
-    noAlias: zod.z.boolean().nullable().optional(),
-    mutableOnlyIfOperandsAreMutable: zod.z.boolean().nullable().optional(),
-    impure: zod.z.boolean().nullable().optional(),
-    canonicalName: zod.z.string().nullable().optional(),
+    noAlias: v4.z.boolean().nullable().optional(),
+    mutableOnlyIfOperandsAreMutable: v4.z.boolean().nullable().optional(),
+    impure: v4.z.boolean().nullable().optional(),
+    canonicalName: v4.z.string().nullable().optional(),
     aliasing: AliasingSignatureSchema.nullable().optional(),
-    knownIncompatible: zod.z.string().nullable().optional(),
+    knownIncompatible: v4.z.string().nullable().optional(),
 });
-const HookTypeSchema = zod.z.object({
-    kind: zod.z.literal('hook'),
-    positionalParams: zod.z.array(EffectSchema).nullable().optional(),
+const HookTypeSchema = v4.z.object({
+    kind: v4.z.literal('hook'),
+    positionalParams: v4.z.array(EffectSchema).nullable().optional(),
     restParam: EffectSchema.nullable().optional(),
-    returnType: zod.z.lazy(() => TypeSchema),
+    returnType: v4.z.lazy(() => TypeSchema),
     returnValueKind: ValueKindSchema.nullable().optional(),
-    noAlias: zod.z.boolean().nullable().optional(),
+    noAlias: v4.z.boolean().nullable().optional(),
     aliasing: AliasingSignatureSchema.nullable().optional(),
-    knownIncompatible: zod.z.string().nullable().optional(),
+    knownIncompatible: v4.z.string().nullable().optional(),
 });
-const BuiltInTypeSchema = zod.z.union([
-    zod.z.literal('Any'),
-    zod.z.literal('Ref'),
-    zod.z.literal('Array'),
-    zod.z.literal('Primitive'),
-    zod.z.literal('MixedReadonly'),
+const BuiltInTypeSchema = v4.z.union([
+    v4.z.literal('Any'),
+    v4.z.literal('Ref'),
+    v4.z.literal('Array'),
+    v4.z.literal('Primitive'),
+    v4.z.literal('MixedReadonly'),
 ]);
-const TypeReferenceSchema = zod.z.object({
-    kind: zod.z.literal('type'),
+const TypeReferenceSchema = v4.z.object({
+    kind: v4.z.literal('type'),
     name: BuiltInTypeSchema,
 });
-const TypeSchema = zod.z.union([
+const TypeSchema = v4.z.union([
     ObjectTypeSchema,
     FunctionTypeSchema,
     HookTypeSchema,
@@ -32052,96 +32052,96 @@ function defaultModuleTypeProvider(moduleName) {
 }
 
 var _Environment_instances, _Environment_globals, _Environment_shapes, _Environment_moduleTypes, _Environment_nextIdentifer, _Environment_nextBlock, _Environment_nextScope, _Environment_scope, _Environment_outlinedFunctions, _Environment_contextIdentifiers, _Environment_hoistedIdentifiers, _Environment_flowTypeEnvironment, _Environment_resolveModuleType, _Environment_isKnownReactModule, _Environment_getCustomHookType;
-const ReactElementSymbolSchema = zod.z.object({
-    elementSymbol: zod.z.union([
-        zod.z.literal('react.element'),
-        zod.z.literal('react.transitional.element'),
+const ReactElementSymbolSchema = v4.z.object({
+    elementSymbol: v4.z.union([
+        v4.z.literal('react.element'),
+        v4.z.literal('react.transitional.element'),
     ]),
-    globalDevVar: zod.z.string(),
+    globalDevVar: v4.z.string(),
 });
-const ExternalFunctionSchema = zod.z.object({
-    source: zod.z.string(),
-    importSpecifierName: zod.z.string(),
+const ExternalFunctionSchema = v4.z.object({
+    source: v4.z.string(),
+    importSpecifierName: v4.z.string(),
 });
-const InstrumentationSchema = zod.z
+const InstrumentationSchema = v4.z
     .object({
     fn: ExternalFunctionSchema,
     gating: ExternalFunctionSchema.nullable(),
-    globalGating: zod.z.string().nullable(),
+    globalGating: v4.z.string().nullable(),
 })
     .refine(opts => opts.gating != null || opts.globalGating != null, 'Expected at least one of gating or globalGating');
 const USE_FIRE_FUNCTION_NAME = 'useFire';
 const EMIT_FREEZE_GLOBAL_GATING = 'true';
-const MacroMethodSchema = zod.z.union([
-    zod.z.object({ type: zod.z.literal('wildcard') }),
-    zod.z.object({ type: zod.z.literal('name'), name: zod.z.string() }),
+const MacroMethodSchema = v4.z.union([
+    v4.z.object({ type: v4.z.literal('wildcard') }),
+    v4.z.object({ type: v4.z.literal('name'), name: v4.z.string() }),
 ]);
-const MacroSchema = zod.z.union([
-    zod.z.string(),
-    zod.z.tuple([zod.z.string(), zod.z.array(MacroMethodSchema)]),
+const MacroSchema = v4.z.union([
+    v4.z.string(),
+    v4.z.tuple([v4.z.string(), v4.z.array(MacroMethodSchema)]),
 ]);
-const HookSchema = zod.z.object({
-    effectKind: zod.z.nativeEnum(Effect),
-    valueKind: zod.z.nativeEnum(ValueKind),
-    noAlias: zod.z.boolean().default(false),
-    transitiveMixedData: zod.z.boolean().default(false),
+const HookSchema = v4.z.object({
+    effectKind: v4.z.nativeEnum(Effect),
+    valueKind: v4.z.nativeEnum(ValueKind),
+    noAlias: v4.z.boolean().default(false),
+    transitiveMixedData: v4.z.boolean().default(false),
 });
-const EnvironmentConfigSchema = zod.z.object({
-    customHooks: zod.z.map(zod.z.string(), HookSchema).default(new Map()),
-    moduleTypeProvider: zod.z.nullable(zod.z.any()).default(null),
-    customMacros: zod.z.nullable(zod.z.array(MacroSchema)).default(null),
-    enableResetCacheOnSourceFileChanges: zod.z.nullable(zod.z.boolean()).default(null),
-    enablePreserveExistingMemoizationGuarantees: zod.z.boolean().default(true),
-    validatePreserveExistingMemoizationGuarantees: zod.z.boolean().default(true),
-    enablePreserveExistingManualUseMemo: zod.z.boolean().default(false),
-    enableForest: zod.z.boolean().default(false),
-    enableUseTypeAnnotations: zod.z.boolean().default(false),
-    flowTypeProvider: zod.z.nullable(zod.z.any()).default(null),
-    enableOptionalDependencies: zod.z.boolean().default(true),
-    enableFire: zod.z.boolean().default(false),
-    enableNameAnonymousFunctions: zod.z.boolean().default(false),
-    inferEffectDependencies: zod.z
-        .nullable(zod.z.array(zod.z.object({
+const EnvironmentConfigSchema = v4.z.object({
+    customHooks: v4.z.map(v4.z.string(), HookSchema).default(new Map()),
+    moduleTypeProvider: v4.z.nullable(v4.z.any()).default(null),
+    customMacros: v4.z.nullable(v4.z.array(MacroSchema)).default(null),
+    enableResetCacheOnSourceFileChanges: v4.z.nullable(v4.z.boolean()).default(null),
+    enablePreserveExistingMemoizationGuarantees: v4.z.boolean().default(true),
+    validatePreserveExistingMemoizationGuarantees: v4.z.boolean().default(true),
+    enablePreserveExistingManualUseMemo: v4.z.boolean().default(false),
+    enableForest: v4.z.boolean().default(false),
+    enableUseTypeAnnotations: v4.z.boolean().default(false),
+    flowTypeProvider: v4.z.nullable(v4.z.any()).default(null),
+    enableOptionalDependencies: v4.z.boolean().default(true),
+    enableFire: v4.z.boolean().default(false),
+    enableNameAnonymousFunctions: v4.z.boolean().default(false),
+    inferEffectDependencies: v4.z
+        .nullable(v4.z.array(v4.z.object({
         function: ExternalFunctionSchema,
-        autodepsIndex: zod.z.number().min(1, 'autodepsIndex must be > 0'),
+        autodepsIndex: v4.z.number().min(1, 'autodepsIndex must be > 0'),
     })))
         .default(null),
     inlineJsxTransform: ReactElementSymbolSchema.nullable().default(null),
-    validateHooksUsage: zod.z.boolean().default(true),
-    validateRefAccessDuringRender: zod.z.boolean().default(true),
-    validateNoSetStateInRender: zod.z.boolean().default(true),
-    validateNoSetStateInEffects: zod.z.boolean().default(false),
-    validateNoDerivedComputationsInEffects: zod.z.boolean().default(false),
-    validateNoJSXInTryStatements: zod.z.boolean().default(false),
-    validateStaticComponents: zod.z.boolean().default(false),
-    validateMemoizedEffectDependencies: zod.z.boolean().default(false),
-    validateNoCapitalizedCalls: zod.z.nullable(zod.z.array(zod.z.string())).default(null),
-    validateBlocklistedImports: zod.z.nullable(zod.z.array(zod.z.string())).default(null),
-    validateNoImpureFunctionsInRender: zod.z.boolean().default(false),
-    validateNoFreezingKnownMutableFunctions: zod.z.boolean().default(false),
-    enableAssumeHooksFollowRulesOfReact: zod.z.boolean().default(true),
-    enableTransitivelyFreezeFunctionExpressions: zod.z.boolean().default(true),
+    validateHooksUsage: v4.z.boolean().default(true),
+    validateRefAccessDuringRender: v4.z.boolean().default(true),
+    validateNoSetStateInRender: v4.z.boolean().default(true),
+    validateNoSetStateInEffects: v4.z.boolean().default(false),
+    validateNoDerivedComputationsInEffects: v4.z.boolean().default(false),
+    validateNoJSXInTryStatements: v4.z.boolean().default(false),
+    validateStaticComponents: v4.z.boolean().default(false),
+    validateMemoizedEffectDependencies: v4.z.boolean().default(false),
+    validateNoCapitalizedCalls: v4.z.nullable(v4.z.array(v4.z.string())).default(null),
+    validateBlocklistedImports: v4.z.nullable(v4.z.array(v4.z.string())).default(null),
+    validateNoImpureFunctionsInRender: v4.z.boolean().default(false),
+    validateNoFreezingKnownMutableFunctions: v4.z.boolean().default(false),
+    enableAssumeHooksFollowRulesOfReact: v4.z.boolean().default(true),
+    enableTransitivelyFreezeFunctionExpressions: v4.z.boolean().default(true),
     enableEmitFreeze: ExternalFunctionSchema.nullable().default(null),
     enableEmitHookGuards: ExternalFunctionSchema.nullable().default(null),
-    enableInstructionReordering: zod.z.boolean().default(false),
-    enableFunctionOutlining: zod.z.boolean().default(true),
-    enableJsxOutlining: zod.z.boolean().default(false),
+    enableInstructionReordering: v4.z.boolean().default(false),
+    enableFunctionOutlining: v4.z.boolean().default(true),
+    enableJsxOutlining: v4.z.boolean().default(false),
     enableEmitInstrumentForget: InstrumentationSchema.nullable().default(null),
-    assertValidMutableRanges: zod.z.boolean().default(false),
-    enableChangeVariableCodegen: zod.z.boolean().default(false),
-    enableMemoizationComments: zod.z.boolean().default(false),
-    throwUnknownException__testonly: zod.z.boolean().default(false),
-    enableTreatFunctionDepsAsConditional: zod.z.boolean().default(false),
-    disableMemoizationForDebugging: zod.z.boolean().default(false),
+    assertValidMutableRanges: v4.z.boolean().default(false),
+    enableChangeVariableCodegen: v4.z.boolean().default(false),
+    enableMemoizationComments: v4.z.boolean().default(false),
+    throwUnknownException__testonly: v4.z.boolean().default(false),
+    enableTreatFunctionDepsAsConditional: v4.z.boolean().default(false),
+    disableMemoizationForDebugging: v4.z.boolean().default(false),
     enableChangeDetectionForDebugging: ExternalFunctionSchema.nullable().default(null),
-    enableCustomTypeDefinitionForReanimated: zod.z.boolean().default(false),
-    hookPattern: zod.z.string().nullable().default(null),
-    enableTreatRefLikeIdentifiersAsRefs: zod.z.boolean().default(true),
-    enableTreatSetIdentifiersAsStateSetters: zod.z.boolean().default(false),
+    enableCustomTypeDefinitionForReanimated: v4.z.boolean().default(false),
+    hookPattern: v4.z.string().nullable().default(null),
+    enableTreatRefLikeIdentifiersAsRefs: v4.z.boolean().default(true),
+    enableTreatSetIdentifiersAsStateSetters: v4.z.boolean().default(false),
     lowerContextAccess: ExternalFunctionSchema.nullable().default(null),
-    validateNoVoidUseMemo: zod.z.boolean().default(false),
-    validateNoDynamicallyCreatedComponentsOrHooks: zod.z.boolean().default(false),
-    enableAllowSetStateFromRefsInEffects: zod.z.boolean().default(true),
+    validateNoVoidUseMemo: v4.z.boolean().default(true),
+    validateNoDynamicallyCreatedComponentsOrHooks: v4.z.boolean().default(false),
+    enableAllowSetStateFromRefsInEffects: v4.z.boolean().default(true),
 });
 class Environment {
     constructor(scope, fnType, compilerMode, config, contextIdentifiers, parentFunction, logger, filename, code, programContext) {
@@ -32518,7 +32518,7 @@ function validateEnvironmentConfig(partialConfig) {
     }
     CompilerError.throwInvalidConfig({
         reason: 'Could not validate environment config. Update React Compiler config to fix the error',
-        description: `${zodValidationError.fromZodError(config.error)}`,
+        description: `${v4$1.fromZodError(config.error)}`,
         loc: null,
         suggestions: null,
     });
@@ -32530,7 +32530,7 @@ function tryParseExternalFunction(maybeExternalFunction) {
     }
     CompilerError.throwInvalidConfig({
         reason: 'Could not parse external function. Update React Compiler config to fix the error',
-        description: `${zodValidationError.fromZodError(externalFunction.error)}`,
+        description: `${v4$1.fromZodError(externalFunction.error)}`,
         loc: null,
         suggestions: null,
     });
@@ -44523,7 +44523,6 @@ function extractManualMemoizationArgs(instr, kind, sidemap, errors) {
     };
 }
 function dropManualMemoization(func) {
-    var _a;
     const errors = new CompilerError();
     const isValidationEnabled = func.env.config.validatePreserveExistingMemoizationGuarantees ||
         func.env.config.validateNoSetStateInRender ||
@@ -44553,26 +44552,6 @@ function dropManualMemoization(func) {
                     if (fnPlace == null) {
                         continue;
                     }
-                    if (func.env.config.validateNoVoidUseMemo &&
-                        manualMemo.kind === 'useMemo') {
-                        const funcToCheck = (_a = sidemap.functions.get(fnPlace.identifier.id)) === null || _a === void 0 ? void 0 : _a.value;
-                        if (funcToCheck !== undefined && funcToCheck.loweredFunc.func) {
-                            if (!hasNonVoidReturn(funcToCheck.loweredFunc.func)) {
-                                errors.pushDiagnostic(CompilerDiagnostic.create({
-                                    category: ErrorCategory.VoidUseMemo,
-                                    reason: 'useMemo() callbacks must return a value',
-                                    description: `This ${manualMemo.loadInstr.value.kind === 'PropertyLoad'
-                                        ? 'React.useMemo'
-                                        : 'useMemo'} callback doesn't return a value. useMemo is for computing and caching values, not for arbitrary side effects`,
-                                    suggestions: null,
-                                }).withDetails({
-                                    kind: 'error',
-                                    loc: instr.value.loc,
-                                    message: 'useMemo() callbacks must return a value',
-                                }));
-                            }
-                        }
-                    }
                     instr.value = getManualMemoizationReplacement(fnPlace, instr.value.loc, manualMemo.kind);
                     if (isValidationEnabled) {
                         if (!sidemap.functions.has(fnPlace.identifier.id)) {
@@ -44684,17 +44663,6 @@ function findOptionalPlaces(fn) {
     }
     return optionals;
 }
-function hasNonVoidReturn(func) {
-    for (const [, block] of func.body.blocks) {
-        if (block.terminal.kind === 'return') {
-            if (block.terminal.returnVariant === 'Explicit' ||
-                block.terminal.returnVariant === 'Implicit') {
-                return true;
-            }
-        }
-    }
-    return false;
-}
 
 class StableSidemap {
     constructor(env) {
@@ -50177,11 +50145,18 @@ function isUnmemoized(operand, scopes) {
 
 function validateUseMemo(fn) {
     const errors = new CompilerError();
+    const voidMemoErrors = new CompilerError();
     const useMemos = new Set();
     const react = new Set();
     const functions = new Map();
+    const unusedUseMemos = new Map();
     for (const [, block] of fn.body.blocks) {
         for (const { lvalue, value } of block.instructions) {
+            if (unusedUseMemos.size !== 0) {
+                for (const operand of eachInstructionValueOperand(value)) {
+                    unusedUseMemos.delete(operand.identifier.id);
+                }
+            }
             switch (value.kind) {
                 case 'LoadGlobal': {
                     if (value.binding.name === 'useMemo') {
@@ -50206,10 +50181,8 @@ function validateUseMemo(fn) {
                 }
                 case 'MethodCall':
                 case 'CallExpression': {
-                    const callee = value.kind === 'CallExpression'
-                        ? value.callee.identifier.id
-                        : value.property.identifier.id;
-                    const isUseMemo = useMemos.has(callee);
+                    const callee = value.kind === 'CallExpression' ? value.callee : value.property;
+                    const isUseMemo = useMemos.has(callee.identifier.id);
                     if (!isUseMemo || value.args.length === 0) {
                         continue;
                     }
@@ -50249,13 +50222,84 @@ function validateUseMemo(fn) {
                             message: 'Async and generator functions are not supported',
                         }));
                     }
+                    validateNoContextVariableAssignment(body.loweredFunc.func, errors);
+                    if (fn.env.config.validateNoVoidUseMemo) {
+                        if (!hasNonVoidReturn(body.loweredFunc.func)) {
+                            voidMemoErrors.pushDiagnostic(CompilerDiagnostic.create({
+                                category: ErrorCategory.VoidUseMemo,
+                                reason: 'useMemo() callbacks must return a value',
+                                description: `This useMemo() callback doesn't return a value. useMemo() is for computing and caching values, not for arbitrary side effects`,
+                                suggestions: null,
+                            }).withDetails({
+                                kind: 'error',
+                                loc: body.loc,
+                                message: 'useMemo() callbacks must return a value',
+                            }));
+                        }
+                        else {
+                            unusedUseMemos.set(lvalue.identifier.id, callee.loc);
+                        }
+                    }
                     break;
                 }
             }
         }
+        if (unusedUseMemos.size !== 0) {
+            for (const operand of eachTerminalOperand(block.terminal)) {
+                unusedUseMemos.delete(operand.identifier.id);
+            }
+        }
     }
+    if (unusedUseMemos.size !== 0) {
+        for (const loc of unusedUseMemos.values()) {
+            voidMemoErrors.pushDiagnostic(CompilerDiagnostic.create({
+                category: ErrorCategory.VoidUseMemo,
+                reason: 'useMemo() result is unused',
+                description: `This useMemo() value is unused. useMemo() is for computing and caching values, not for arbitrary side effects`,
+                suggestions: null,
+            }).withDetails({
+                kind: 'error',
+                loc,
+                message: 'useMemo() result is unused',
+            }));
+        }
+    }
+    fn.env.logErrors(voidMemoErrors.asResult());
     return errors.asResult();
 }
+function validateNoContextVariableAssignment(fn, errors) {
+    for (const block of fn.body.blocks.values()) {
+        for (const instr of block.instructions) {
+            const value = instr.value;
+            switch (value.kind) {
+                case 'StoreContext': {
+                    errors.pushDiagnostic(CompilerDiagnostic.create({
+                        category: ErrorCategory.UseMemo,
+                        reason: 'useMemo() callbacks may not reassign variables declared outside of the callback',
+                        description: 'useMemo() callbacks must be pure functions and cannot reassign variables defined outside of the callback function',
+                        suggestions: null,
+                    }).withDetails({
+                        kind: 'error',
+                        loc: value.lvalue.place.loc,
+                        message: 'Cannot reassign variable',
+                    }));
+                    break;
+                }
+            }
+        }
+    }
+}
+function hasNonVoidReturn(func) {
+    for (const [, block] of func.body.blocks) {
+        if (block.terminal.kind === 'return') {
+            if (block.terminal.returnVariant === 'Explicit' ||
+                block.terminal.returnVariant === 'Implicit') {
+                return true;
+            }
+        }
+    }
+    return false;
+}
 
 function validateLocalsNotReassignedAfterRender(fn) {
     const contextVariables = new Set();
@@ -53700,27 +53744,27 @@ function isNonNamespacedImport(importDeclPath) {
         importDeclPath.node.importKind !== 'typeof');
 }
 
-zod.z.enum([
+v4.z.enum([
     'all_errors',
     'critical_errors',
     'none',
 ]);
-const DynamicGatingOptionsSchema = zod.z.object({
-    source: zod.z.string(),
+const DynamicGatingOptionsSchema = v4.z.object({
+    source: v4.z.string(),
 });
-const CustomOptOutDirectiveSchema = zod.z
-    .nullable(zod.z.array(zod.z.string()))
+const CustomOptOutDirectiveSchema = v4.z
+    .nullable(v4.z.array(v4.z.string()))
     .default(null);
-const CompilerReactTargetSchema = zod.z.union([
-    zod.z.literal('17'),
-    zod.z.literal('18'),
-    zod.z.literal('19'),
-    zod.z.object({
-        kind: zod.z.literal('donotuse_meta_internal'),
-        runtimeModule: zod.z.string().default('react'),
+const CompilerReactTargetSchema = v4.z.union([
+    v4.z.literal('17'),
+    v4.z.literal('18'),
+    v4.z.literal('19'),
+    v4.z.object({
+        kind: v4.z.literal('donotuse_meta_internal'),
+        runtimeModule: v4.z.string().default('react'),
     }),
 ]);
-zod.z.enum([
+v4.z.enum([
     'infer',
     'syntax',
     'annotation',
@@ -53793,7 +53837,7 @@ function parsePluginOptions(obj) {
                         else {
                             CompilerError.throwInvalidConfig({
                                 reason: 'Could not parse dynamic gating. Update React Compiler config to fix the error',
-                                description: `${zodValidationError.fromZodError(result.error)}`,
+                                description: `${v4$1.fromZodError(result.error)}`,
                                 loc: null,
                                 suggestions: null,
                             });
@@ -53809,7 +53853,7 @@ function parsePluginOptions(obj) {
                     else {
                         CompilerError.throwInvalidConfig({
                             reason: 'Could not parse custom opt out directives. Update React Compiler config to fix the error',
-                            description: `${zodValidationError.fromZodError(result.error)}`,
+                            description: `${v4$1.fromZodError(result.error)}`,
                             loc: null,
                             suggestions: null,
                         });
@@ -53832,7 +53876,7 @@ function parseTargetConfig(value) {
     else {
         CompilerError.throwInvalidConfig({
             reason: 'Not a valid target',
-            description: `${zodValidationError.fromZodError(parsed.error)}`,
+            description: `${v4$1.fromZodError(parsed.error)}`,
             suggestions: null,
             loc: null,
         });
@@ -57346,6 +57390,10 @@ function isUseEffectEventIdentifier(node) {
     return node.type === 'Identifier' && node.name === 'useEffectEvent';
 }
 function useEffectEventError(fn, called) {
+    if (fn === null) {
+        return (`React Hook "useEffectEvent" can only be called at the top level of your component.` +
+            ` It cannot be passed down.`);
+    }
     return (`\`${fn}\` is a function created with React Hook "useEffectEvent", and can only be called from ` +
         'Effects and Effect Events in the same component.' +
         (called ? '' : ' It cannot be assigned to a variable or passed down.'));
@@ -57645,6 +57693,7 @@ const rule = {
                 analyzer.leaveNode(node);
             },
             CallExpression(node) {
+                var _a, _b;
                 if (isHook(node.callee)) {
                     const reactHooksMap = last(codePathReactHooksMapStack);
                     const codePathSegment = last(codePathSegmentStack);
@@ -57661,6 +57710,15 @@ const rule = {
                     node.arguments.length > 0) {
                     lastEffect = node;
                 }
+                if (isUseEffectEventIdentifier(nodeWithoutNamespace) &&
+                    ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.type) !== 'VariableDeclarator' &&
+                    ((_b = node.parent) === null || _b === void 0 ? void 0 : _b.type) !== 'ExpressionStatement') {
+                    const message = useEffectEventError(null, false);
+                    context.report({
+                        node,
+                        message,
+                    });
+                }
             },
             Identifier(node) {
                 if (lastEffect == null && useEffectEventFunctions.has(node)) {