eslint-plugin-react-hooks 7.0.0-canary-93f85932-20251016 → 7.0.0-canary-58bdc0bb-20251019

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,
@@ -21185,25 +21185,25 @@ function assertValidBlockNesting(fn) {
 function assertValidMutableRanges(fn) {
     for (const [, block] of fn.body.blocks) {
         for (const phi of block.phis) {
-            visit$2(phi.place, `phi for block bb${block.id}`);
+            visit$1(phi.place, `phi for block bb${block.id}`);
             for (const [pred, operand] of phi.operands) {
-                visit$2(operand, `phi predecessor bb${pred} for block bb${block.id}`);
+                visit$1(operand, `phi predecessor bb${pred} for block bb${block.id}`);
             }
         }
         for (const instr of block.instructions) {
             for (const operand of eachInstructionLValue(instr)) {
-                visit$2(operand, `instruction [${instr.id}]`);
+                visit$1(operand, `instruction [${instr.id}]`);
             }
             for (const operand of eachInstructionOperand(instr)) {
-                visit$2(operand, `instruction [${instr.id}]`);
+                visit$1(operand, `instruction [${instr.id}]`);
             }
         }
         for (const operand of eachTerminalOperand(block.terminal)) {
-            visit$2(operand, `terminal [${block.terminal.id}]`);
+            visit$1(operand, `terminal [${block.terminal.id}]`);
         }
     }
 }
-function visit$2(place, description) {
+function visit$1(place, description) {
     validateMutableRange(place, place.identifier.mutableRange, description);
     if (place.identifier.scope !== null) {
         validateMutableRange(place, place.identifier.scope.range, description);
@@ -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,89 @@ 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 MacroSchema = zod.z.union([
-    zod.z.string(),
-    zod.z.tuple([zod.z.string(), zod.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 MacroSchema = v4.z.string();
+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 +32511,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 +32523,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,
     });
@@ -37124,174 +37117,189 @@ var GuardKind;
     GuardKind[GuardKind["DisallowHook"] = 3] = "DisallowHook";
 })(GuardKind || (GuardKind = {}));
 
+var InlineLevel;
+(function (InlineLevel) {
+    InlineLevel["Transitive"] = "Transitive";
+    InlineLevel["Shallow"] = "Shallow";
+})(InlineLevel || (InlineLevel = {}));
+const SHALLOW_MACRO = {
+    level: InlineLevel.Shallow,
+    properties: null,
+};
+const TRANSITIVE_MACRO = {
+    level: InlineLevel.Transitive,
+    properties: null,
+};
+const FBT_MACRO = {
+    level: InlineLevel.Transitive,
+    properties: new Map([['*', SHALLOW_MACRO]]),
+};
+FBT_MACRO.properties.set('enum', FBT_MACRO);
 function memoizeFbtAndMacroOperandsInSameScope(fn) {
     var _a;
-    const fbtMacroTags = new Set([
-        ...Array.from(FBT_TAGS).map((tag) => [tag, []]),
-        ...((_a = fn.env.config.customMacros) !== null && _a !== void 0 ? _a : []),
+    const macroKinds = new Map([
+        ...Array.from(FBT_TAGS.entries()),
+        ...((_a = fn.env.config.customMacros) !== null && _a !== void 0 ? _a : []).map(name => [name, TRANSITIVE_MACRO]),
     ]);
-    const macroTagsCalls = new Set();
-    const macroValues = new Map();
-    const macroMethods = new Map();
-    visit$1(fn, fbtMacroTags, macroTagsCalls, macroMethods, macroValues);
-    for (const root of macroValues.keys()) {
-        const scope = root.scope;
-        if (scope == null) {
-            continue;
-        }
-        if (!macroTagsCalls.has(root.id)) {
-            continue;
-        }
-        mergeScopes(root, scope, macroValues, macroTagsCalls);
-    }
-    return macroTagsCalls;
-}
-const FBT_TAGS = new Set([
-    'fbt',
-    'fbt:param',
-    'fbt:enum',
-    'fbt:plural',
-    'fbs',
-    'fbs:param',
-    'fbs:enum',
-    'fbs:plural',
+    const macroTags = populateMacroTags(fn, macroKinds);
+    const macroValues = mergeMacroArguments(fn, macroTags, macroKinds);
+    return macroValues;
+}
+const FBT_TAGS = new Map([
+    ['fbt', FBT_MACRO],
+    ['fbt:param', SHALLOW_MACRO],
+    ['fbt:enum', FBT_MACRO],
+    ['fbt:plural', SHALLOW_MACRO],
+    ['fbs', FBT_MACRO],
+    ['fbs:param', SHALLOW_MACRO],
+    ['fbs:enum', FBT_MACRO],
+    ['fbs:plural', SHALLOW_MACRO],
 ]);
 const SINGLE_CHILD_FBT_TAGS = new Set([
     'fbt:param',
     'fbs:param',
 ]);
-function visit$1(fn, fbtMacroTags, macroTagsCalls, macroMethods, macroValues) {
-    for (const [, block] of fn.body.blocks) {
-        for (const phi of block.phis) {
-            const macroOperands = [];
-            for (const operand of phi.operands.values()) {
-                if (macroValues.has(operand.identifier)) {
-                    macroOperands.push(operand.identifier);
-                }
-            }
-            if (macroOperands.length !== 0) {
-                macroValues.set(phi.place.identifier, macroOperands);
-            }
-        }
-        for (const instruction of block.instructions) {
-            const { lvalue, value } = instruction;
-            if (lvalue === null) {
-                continue;
-            }
-            if (value.kind === 'Primitive' &&
-                typeof value.value === 'string' &&
-                matchesExactTag(value.value, fbtMacroTags)) {
-                macroTagsCalls.add(lvalue.identifier.id);
-            }
-            else if (value.kind === 'LoadGlobal' &&
-                matchesExactTag(value.binding.name, fbtMacroTags)) {
-                macroTagsCalls.add(lvalue.identifier.id);
-            }
-            else if (value.kind === 'LoadGlobal' &&
-                matchTagRoot(value.binding.name, fbtMacroTags) !== null) {
-                const methods = matchTagRoot(value.binding.name, fbtMacroTags);
-                macroMethods.set(lvalue.identifier.id, methods);
-            }
-            else if (value.kind === 'PropertyLoad' &&
-                macroMethods.has(value.object.identifier.id)) {
-                const methods = macroMethods.get(value.object.identifier.id);
-                const newMethods = [];
-                for (const method of methods) {
-                    if (method.length > 0 &&
-                        (method[0].type === 'wildcard' ||
-                            (method[0].type === 'name' && method[0].name === value.property))) {
-                        if (method.length > 1) {
-                            newMethods.push(method.slice(1));
-                        }
-                        else {
-                            macroTagsCalls.add(lvalue.identifier.id);
+function populateMacroTags(fn, macroKinds) {
+    var _a;
+    const macroTags = new Map();
+    for (const block of fn.body.blocks.values()) {
+        for (const instr of block.instructions) {
+            const { lvalue, value } = instr;
+            switch (value.kind) {
+                case 'Primitive': {
+                    if (typeof value.value === 'string') {
+                        const macroDefinition = macroKinds.get(value.value);
+                        if (macroDefinition != null) {
+                            macroTags.set(lvalue.identifier.id, macroDefinition);
                         }
                     }
+                    break;
                 }
-                if (newMethods.length > 0) {
-                    macroMethods.set(lvalue.identifier.id, newMethods);
+                case 'LoadGlobal': {
+                    let macroDefinition = macroKinds.get(value.binding.name);
+                    if (macroDefinition != null) {
+                        macroTags.set(lvalue.identifier.id, macroDefinition);
+                    }
+                    break;
                 }
-            }
-            else if (value.kind === 'PropertyLoad' &&
-                macroTagsCalls.has(value.object.identifier.id)) {
-                macroTagsCalls.add(lvalue.identifier.id);
-            }
-            else if (isFbtJsxExpression(fbtMacroTags, macroTagsCalls, value) ||
-                isFbtJsxChild(macroTagsCalls, lvalue, value) ||
-                isFbtCallExpression(macroTagsCalls, value)) {
-                macroTagsCalls.add(lvalue.identifier.id);
-                macroValues.set(lvalue.identifier, Array.from(eachInstructionValueOperand(value), operand => operand.identifier));
-            }
-            else if (Iterable_some(eachInstructionValueOperand(value), operand => macroValues.has(operand.identifier))) {
-                const macroOperands = [];
-                for (const operand of eachInstructionValueOperand(value)) {
-                    if (macroValues.has(operand.identifier)) {
-                        macroOperands.push(operand.identifier);
+                case 'PropertyLoad': {
+                    if (typeof value.property === 'string') {
+                        const macroDefinition = macroTags.get(value.object.identifier.id);
+                        if (macroDefinition != null) {
+                            const propertyDefinition = macroDefinition.properties != null
+                                ? ((_a = macroDefinition.properties.get(value.property)) !== null && _a !== void 0 ? _a : macroDefinition.properties.get('*'))
+                                : null;
+                            const propertyMacro = propertyDefinition !== null && propertyDefinition !== void 0 ? propertyDefinition : macroDefinition;
+                            macroTags.set(lvalue.identifier.id, propertyMacro);
+                        }
                     }
+                    break;
                 }
-                macroValues.set(lvalue.identifier, macroOperands);
             }
         }
     }
+    return macroTags;
 }
-function mergeScopes(root, scope, macroValues, macroTagsCalls) {
-    const operands = macroValues.get(root);
-    if (operands == null) {
-        return;
-    }
-    for (const operand of operands) {
-        operand.scope = scope;
-        expandFbtScopeRange(scope.range, operand.mutableRange);
-        macroTagsCalls.add(operand.id);
-        mergeScopes(operand, scope, macroValues, macroTagsCalls);
-    }
-}
-function matchesExactTag(s, tags) {
-    return Array.from(tags).some(macro => typeof macro === 'string'
-        ? s === macro
-        : macro[1].length === 0 && macro[0] === s);
-}
-function matchTagRoot(s, tags) {
-    const methods = [];
-    for (const macro of tags) {
-        if (typeof macro === 'string') {
-            continue;
+function mergeMacroArguments(fn, macroTags, macroKinds) {
+    var _a;
+    const macroValues = new Set(macroTags.keys());
+    for (const block of Array.from(fn.body.blocks.values()).reverse()) {
+        for (let i = block.instructions.length - 1; i >= 0; i--) {
+            const instr = block.instructions[i];
+            const { lvalue, value } = instr;
+            switch (value.kind) {
+                case 'DeclareContext':
+                case 'DeclareLocal':
+                case 'Destructure':
+                case 'LoadContext':
+                case 'LoadLocal':
+                case 'PostfixUpdate':
+                case 'PrefixUpdate':
+                case 'StoreContext':
+                case 'StoreLocal': {
+                    break;
+                }
+                case 'CallExpression':
+                case 'MethodCall': {
+                    const scope = lvalue.identifier.scope;
+                    if (scope == null) {
+                        continue;
+                    }
+                    const callee = value.kind === 'CallExpression' ? value.callee : value.property;
+                    const macroDefinition = (_a = macroTags.get(callee.identifier.id)) !== null && _a !== void 0 ? _a : macroTags.get(lvalue.identifier.id);
+                    if (macroDefinition != null) {
+                        visitOperands(macroDefinition, scope, lvalue, value, macroValues, macroTags);
+                    }
+                    break;
+                }
+                case 'JsxExpression': {
+                    const scope = lvalue.identifier.scope;
+                    if (scope == null) {
+                        continue;
+                    }
+                    let macroDefinition;
+                    if (value.tag.kind === 'Identifier') {
+                        macroDefinition = macroTags.get(value.tag.identifier.id);
+                    }
+                    else {
+                        macroDefinition = macroKinds.get(value.tag.name);
+                    }
+                    macroDefinition !== null && macroDefinition !== void 0 ? macroDefinition : (macroDefinition = macroTags.get(lvalue.identifier.id));
+                    if (macroDefinition != null) {
+                        visitOperands(macroDefinition, scope, lvalue, value, macroValues, macroTags);
+                    }
+                    break;
+                }
+                default: {
+                    const scope = lvalue.identifier.scope;
+                    if (scope == null) {
+                        continue;
+                    }
+                    const macroDefinition = macroTags.get(lvalue.identifier.id);
+                    if (macroDefinition != null) {
+                        visitOperands(macroDefinition, scope, lvalue, value, macroValues, macroTags);
+                    }
+                    break;
+                }
+            }
         }
-        const [tag, rest] = macro;
-        if (tag === s && rest.length > 0) {
-            methods.push(rest);
+        for (const phi of block.phis) {
+            const scope = phi.place.identifier.scope;
+            if (scope == null) {
+                continue;
+            }
+            const macroDefinition = macroTags.get(phi.place.identifier.id);
+            if (macroDefinition == null ||
+                macroDefinition.level === InlineLevel.Shallow) {
+                continue;
+            }
+            macroValues.add(phi.place.identifier.id);
+            for (const operand of phi.operands.values()) {
+                operand.identifier.scope = scope;
+                expandFbtScopeRange(scope.range, operand.identifier.mutableRange);
+                macroTags.set(operand.identifier.id, macroDefinition);
+                macroValues.add(operand.identifier.id);
+            }
         }
     }
-    if (methods.length > 0) {
-        return methods;
-    }
-    else {
-        return null;
-    }
-}
-function isFbtCallExpression(macroTagsCalls, value) {
-    return ((value.kind === 'CallExpression' &&
-        macroTagsCalls.has(value.callee.identifier.id)) ||
-        (value.kind === 'MethodCall' &&
-            macroTagsCalls.has(value.property.identifier.id)));
-}
-function isFbtJsxExpression(fbtMacroTags, macroTagsCalls, value) {
-    return (value.kind === 'JsxExpression' &&
-        ((value.tag.kind === 'Identifier' &&
-            macroTagsCalls.has(value.tag.identifier.id)) ||
-            (value.tag.kind === 'BuiltinTag' &&
-                matchesExactTag(value.tag.name, fbtMacroTags))));
-}
-function isFbtJsxChild(macroTagsCalls, lvalue, value) {
-    return ((value.kind === 'JsxExpression' || value.kind === 'JsxFragment') &&
-        lvalue !== null &&
-        macroTagsCalls.has(lvalue.identifier.id));
+    return macroValues;
 }
 function expandFbtScopeRange(fbtRange, extendWith) {
     if (extendWith.start !== 0) {
         fbtRange.start = makeInstructionId(Math.min(fbtRange.start, extendWith.start));
     }
 }
+function visitOperands(macroDefinition, scope, lvalue, value, macroValues, macroTags) {
+    macroValues.add(lvalue.identifier.id);
+    for (const operand of eachInstructionValueOperand(value)) {
+        if (macroDefinition.level === InlineLevel.Transitive) {
+            operand.identifier.scope = scope;
+            expandFbtScopeRange(scope.range, operand.identifier.mutableRange);
+            macroTags.set(operand.identifier.id, macroDefinition);
+        }
+        macroValues.add(operand.identifier.id);
+    }
+}
 
 var _Context_nextCacheIndex, _Context_declarations;
 const MEMO_CACHE_SENTINEL = 'react.memo_cache_sentinel';
@@ -40489,7 +40497,7 @@ function inferMutationAliasingEffects(fn, { isFunctionExpression } = {
     }
     queue(fn.body.entry, initialState);
     const hoistedContextDeclarations = findHoistedContextDeclarations(fn);
-    const context = new Context$1(isFunctionExpression, fn, hoistedContextDeclarations);
+    const context = new Context$1(isFunctionExpression, fn, hoistedContextDeclarations, findNonMutatedDestructureSpreads(fn));
     let iterationCount = 0;
     while (queuedStates.size !== 0) {
         iterationCount++;
@@ -40553,7 +40561,7 @@ function findHoistedContextDeclarations(fn) {
     return hoisted;
 }
 let Context$1 = class Context {
-    constructor(isFunctionExpression, fn, hoistedContextDeclarations) {
+    constructor(isFunctionExpression, fn, hoistedContextDeclarations, nonMutatingSpreads) {
         this.internedEffects = new Map();
         this.instructionSignatureCache = new Map();
         this.effectInstructionValueCache = new Map();
@@ -40563,6 +40571,7 @@ let Context$1 = class Context {
         this.isFuctionExpression = isFunctionExpression;
         this.fn = fn;
         this.hoistedContextDeclarations = hoistedContextDeclarations;
+        this.nonMutatingSpreads = nonMutatingSpreads;
     }
     cacheApplySignature(signature, effect, f) {
         const inner = getOrInsertDefault(this.applySignatureCache, signature, new Map());
@@ -40578,6 +40587,114 @@ let Context$1 = class Context {
         return interned;
     }
 };
+function findNonMutatedDestructureSpreads(fn) {
+    const knownFrozen = new Set();
+    if (fn.fnType === 'Component') {
+        const [props] = fn.params;
+        if (props != null && props.kind === 'Identifier') {
+            knownFrozen.add(props.identifier.id);
+        }
+    }
+    else {
+        for (const param of fn.params) {
+            if (param.kind === 'Identifier') {
+                knownFrozen.add(param.identifier.id);
+            }
+        }
+    }
+    const candidateNonMutatingSpreads = new Map();
+    for (const block of fn.body.blocks.values()) {
+        if (candidateNonMutatingSpreads.size !== 0) {
+            for (const phi of block.phis) {
+                for (const operand of phi.operands.values()) {
+                    const spread = candidateNonMutatingSpreads.get(operand.identifier.id);
+                    if (spread != null) {
+                        candidateNonMutatingSpreads.delete(spread);
+                    }
+                }
+            }
+        }
+        for (const instr of block.instructions) {
+            const { lvalue, value } = instr;
+            switch (value.kind) {
+                case 'Destructure': {
+                    if (!knownFrozen.has(value.value.identifier.id) ||
+                        !(value.lvalue.kind === InstructionKind.Let ||
+                            value.lvalue.kind === InstructionKind.Const) ||
+                        value.lvalue.pattern.kind !== 'ObjectPattern') {
+                        continue;
+                    }
+                    for (const item of value.lvalue.pattern.properties) {
+                        if (item.kind !== 'Spread') {
+                            continue;
+                        }
+                        candidateNonMutatingSpreads.set(item.place.identifier.id, item.place.identifier.id);
+                    }
+                    break;
+                }
+                case 'LoadLocal': {
+                    const spread = candidateNonMutatingSpreads.get(value.place.identifier.id);
+                    if (spread != null) {
+                        candidateNonMutatingSpreads.set(lvalue.identifier.id, spread);
+                    }
+                    break;
+                }
+                case 'StoreLocal': {
+                    const spread = candidateNonMutatingSpreads.get(value.value.identifier.id);
+                    if (spread != null) {
+                        candidateNonMutatingSpreads.set(lvalue.identifier.id, spread);
+                        candidateNonMutatingSpreads.set(value.lvalue.place.identifier.id, spread);
+                    }
+                    break;
+                }
+                case 'JsxFragment':
+                case 'JsxExpression': {
+                    break;
+                }
+                case 'PropertyLoad': {
+                    break;
+                }
+                case 'CallExpression':
+                case 'MethodCall': {
+                    const callee = value.kind === 'CallExpression' ? value.callee : value.property;
+                    if (getHookKind(fn.env, callee.identifier) != null) {
+                        if (!isRefOrRefValue(lvalue.identifier)) {
+                            knownFrozen.add(lvalue.identifier.id);
+                        }
+                    }
+                    else {
+                        if (candidateNonMutatingSpreads.size !== 0) {
+                            for (const operand of eachInstructionValueOperand(value)) {
+                                const spread = candidateNonMutatingSpreads.get(operand.identifier.id);
+                                if (spread != null) {
+                                    candidateNonMutatingSpreads.delete(spread);
+                                }
+                            }
+                        }
+                    }
+                    break;
+                }
+                default: {
+                    if (candidateNonMutatingSpreads.size !== 0) {
+                        for (const operand of eachInstructionValueOperand(value)) {
+                            const spread = candidateNonMutatingSpreads.get(operand.identifier.id);
+                            if (spread != null) {
+                                candidateNonMutatingSpreads.delete(spread);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    const nonMutatingSpreads = new Set();
+    for (const [key, value] of candidateNonMutatingSpreads) {
+        if (key === value) {
+            nonMutatingSpreads.add(key);
+        }
+    }
+    return nonMutatingSpreads;
+}
 function inferParam(param, initialState, paramKind) {
     const place = param.kind === 'Identifier' ? param : param.place;
     const value = {
@@ -41832,7 +41949,9 @@ function computeSignatureForInstruction(context, env, instr) {
                         kind: 'Create',
                         into: place,
                         reason: ValueReason.Other,
-                        value: ValueKind.Mutable,
+                        value: context.nonMutatingSpreads.has(place.identifier.id)
+                            ? ValueKind.Frozen
+                            : ValueKind.Mutable,
                     });
                     effects.push({
                         kind: 'Capture',
@@ -44523,7 +44642,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 +44671,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 +44782,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 +50264,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 +50300,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 +50341,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 +53863,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 +53956,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 +53972,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 +53995,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 +57509,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 +57812,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 +57829,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)) {