eslint-plugin-react-hooks 7.0.0 → 7.0.1

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');
@@ -17648,6 +17648,10 @@ function hasOwnProperty$1(obj, key) {
     return Object.prototype.hasOwnProperty.call(obj, key);
 }
 
+const CODEFRAME_LINES_ABOVE = 2;
+const CODEFRAME_LINES_BELOW = 3;
+const CODEFRAME_MAX_LINES = 10;
+const CODEFRAME_ABBREVIATED_SOURCE_LINES = 5;
 var ErrorSeverity;
 (function (ErrorSeverity) {
     ErrorSeverity["Error"] = "Error";
@@ -17964,7 +17968,7 @@ class CompilerError extends Error {
     }
 }
 function printCodeFrame(source, loc, message) {
-    return libExports.codeFrameColumns(source, {
+    const printed = libExports.codeFrameColumns(source, {
         start: {
             line: loc.start.line,
             column: loc.start.column + 1,
@@ -17975,7 +17979,19 @@ function printCodeFrame(source, loc, message) {
         },
     }, {
         message,
+        linesAbove: CODEFRAME_LINES_ABOVE,
+        linesBelow: CODEFRAME_LINES_BELOW,
     });
+    const lines = printed.split(/\r?\n/);
+    if (loc.end.line - loc.start.line < CODEFRAME_MAX_LINES) {
+        return printed;
+    }
+    const pipeIndex = lines[0].indexOf('|');
+    return [
+        ...lines.slice(0, CODEFRAME_LINES_ABOVE + CODEFRAME_ABBREVIATED_SOURCE_LINES),
+        ' '.repeat(pipeIndex) + '…',
+        ...lines.slice(-(CODEFRAME_LINES_BELOW + CODEFRAME_ABBREVIATED_SOURCE_LINES)),
+    ].join('\n');
 }
 function printErrorSummary(category, message) {
     let heading;
@@ -18303,7 +18319,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 +18751,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 +18759,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 +18783,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 +21201,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);
@@ -24145,7 +24161,7 @@ function lowerObjectMethod(builder, property) {
     };
 }
 function lowerObjectPropertyKey(builder, property) {
-    var _a, _b;
+    var _a;
     const key = property.get('key');
     if (key.isStringLiteral()) {
         return {
@@ -24154,15 +24170,6 @@ function lowerObjectPropertyKey(builder, property) {
         };
     }
     else if (property.node.computed && key.isExpression()) {
-        if (!key.isIdentifier() && !key.isMemberExpression()) {
-            builder.errors.push({
-                reason: `(BuildHIR::lowerExpression) Expected Identifier, got ${key.type} key in ObjectExpression`,
-                category: ErrorCategory.Todo,
-                loc: (_a = key.node.loc) !== null && _a !== void 0 ? _a : null,
-                suggestions: null,
-            });
-            return null;
-        }
         const place = lowerExpressionToTemporary(builder, key);
         return {
             kind: 'computed',
@@ -24184,7 +24191,7 @@ function lowerObjectPropertyKey(builder, property) {
     builder.errors.push({
         reason: `(BuildHIR::lowerExpression) Expected Identifier, got ${key.type} key in ObjectExpression`,
         category: ErrorCategory.Todo,
-        loc: (_b = key.node.loc) !== null && _b !== void 0 ? _b : null,
+        loc: (_a = key.node.loc) !== null && _a !== void 0 ? _a : null,
         suggestions: null,
     });
     return null;
@@ -31322,85 +31329,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 +31420,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 +32059,90 @@ 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),
+    validateNoDerivedComputationsInEffects_exp: 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 +32519,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 +32531,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,160 +37125,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 fbtValues = new Set();
-    const macroMethods = new Map();
-    while (true) {
-        let vsize = fbtValues.size;
-        let msize = macroMethods.size;
-        visit$1(fn, fbtMacroTags, fbtValues, macroMethods);
-        if (vsize === fbtValues.size && msize === macroMethods.size) {
-            break;
-        }
-    }
-    return fbtValues;
-}
-const FBT_TAGS = new Set([
-    'fbt',
-    'fbt:param',
-    'fbs',
-    'fbs:param',
+    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, fbtValues, macroMethods) {
-    for (const [, block] of fn.body.blocks) {
-        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)) {
-                fbtValues.add(lvalue.identifier.id);
-            }
-            else if (value.kind === 'LoadGlobal' &&
-                matchesExactTag(value.binding.name, fbtMacroTags)) {
-                fbtValues.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 {
-                            fbtValues.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);
-                }
-            }
-            else if (isFbtCallExpression(fbtValues, value)) {
-                const fbtScope = lvalue.identifier.scope;
-                if (fbtScope === null) {
-                    continue;
+                case 'LoadGlobal': {
+                    let macroDefinition = macroKinds.get(value.binding.name);
+                    if (macroDefinition != null) {
+                        macroTags.set(lvalue.identifier.id, macroDefinition);
+                    }
+                    break;
                 }
-                for (const operand of eachReactiveValueOperand(value)) {
-                    operand.identifier.scope = fbtScope;
-                    expandFbtScopeRange(fbtScope.range, operand.identifier.mutableRange);
-                    fbtValues.add(operand.identifier.id);
+                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;
                 }
             }
-            else if (isFbtJsxExpression(fbtMacroTags, fbtValues, value) ||
-                isFbtJsxChild(fbtValues, lvalue, value)) {
-                const fbtScope = lvalue.identifier.scope;
-                if (fbtScope === null) {
-                    continue;
+        }
+    }
+    return macroTags;
+}
+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;
                 }
-                for (const operand of eachReactiveValueOperand(value)) {
-                    operand.identifier.scope = fbtScope;
-                    expandFbtScopeRange(fbtScope.range, operand.identifier.mutableRange);
-                    fbtValues.add(operand.identifier.id);
+                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;
                 }
-            }
-            else if (fbtValues.has(lvalue.identifier.id)) {
-                const fbtScope = lvalue.identifier.scope;
-                if (fbtScope === null) {
-                    return;
+                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;
                 }
-                for (const operand of eachReactiveValueOperand(value)) {
-                    if (operand.identifier.name !== null &&
-                        operand.identifier.name.kind === 'named') {
+                default: {
+                    const scope = lvalue.identifier.scope;
+                    if (scope == null) {
                         continue;
                     }
-                    operand.identifier.scope = fbtScope;
-                    expandFbtScopeRange(fbtScope.range, operand.identifier.mutableRange);
+                    const macroDefinition = macroTags.get(lvalue.identifier.id);
+                    if (macroDefinition != null) {
+                        visitOperands(macroDefinition, scope, lvalue, value, macroValues, macroTags);
+                    }
+                    break;
                 }
             }
         }
-    }
-}
-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;
-        }
-        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(fbtValues, value) {
-    return ((value.kind === 'CallExpression' &&
-        fbtValues.has(value.callee.identifier.id)) ||
-        (value.kind === 'MethodCall' && fbtValues.has(value.property.identifier.id)));
-}
-function isFbtJsxExpression(fbtMacroTags, fbtValues, value) {
-    return (value.kind === 'JsxExpression' &&
-        ((value.tag.kind === 'Identifier' &&
-            fbtValues.has(value.tag.identifier.id)) ||
-            (value.tag.kind === 'BuiltinTag' &&
-                matchesExactTag(value.tag.name, fbtMacroTags))));
-}
-function isFbtJsxChild(fbtValues, lvalue, value) {
-    return ((value.kind === 'JsxExpression' || value.kind === 'JsxFragment') &&
-        lvalue !== null &&
-        fbtValues.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';
@@ -40475,7 +40505,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++;
@@ -40539,7 +40569,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();
@@ -40549,6 +40579,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());
@@ -40564,6 +40595,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 = {
@@ -41818,7 +41957,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',
@@ -44509,7 +44650,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 ||
@@ -44539,26 +44679,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)) {
@@ -44670,17 +44790,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) {
@@ -48124,7 +48233,7 @@ function* generateInstructionTypes(env, names, instr) {
                         });
                     }
                     else {
-                        break;
+                        continue;
                     }
                 }
             }
@@ -50163,11 +50272,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') {
@@ -50192,10 +50308,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;
                     }
@@ -50235,13 +50349,87 @@ 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) {
+    const context = new Set(fn.context.map(place => place.identifier.id));
+    for (const block of fn.body.blocks.values()) {
+        for (const instr of block.instructions) {
+            const value = instr.value;
+            switch (value.kind) {
+                case 'StoreContext': {
+                    if (context.has(value.lvalue.place.identifier.id)) {
+                        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();
@@ -51867,7 +52055,7 @@ function validateNoDerivedComputationsInEffects(fn) {
                             });
                             return (_a = locals.get(dep.identifier.id)) !== null && _a !== void 0 ? _a : dep.identifier.id;
                         });
-                        validateEffect(effectFunction.loweredFunc.func, dependencies, errors);
+                        validateEffect$1(effectFunction.loweredFunc.func, dependencies, errors);
                     }
                 }
             }
@@ -51877,7 +52065,7 @@ function validateNoDerivedComputationsInEffects(fn) {
         throw errors;
     }
 }
-function validateEffect(effectFunction, effectDeps, errors) {
+function validateEffect$1(effectFunction, effectDeps, errors) {
     for (const operand of effectFunction.context) {
         if (isSetStateType(operand.identifier)) {
             continue;
@@ -51990,6 +52178,339 @@ function validateEffect(effectFunction, effectDeps, errors) {
     }
 }
 
+class DerivationCache {
+    constructor() {
+        this.hasChanges = false;
+        this.cache = new Map();
+    }
+    snapshot() {
+        const hasChanges = this.hasChanges;
+        this.hasChanges = false;
+        return hasChanges;
+    }
+    addDerivationEntry(derivedVar, sourcesIds, typeOfValue) {
+        var _a, _b;
+        let newValue = {
+            place: derivedVar,
+            sourcesIds: new Set(),
+            typeOfValue: typeOfValue !== null && typeOfValue !== void 0 ? typeOfValue : 'ignored',
+        };
+        if (sourcesIds !== undefined) {
+            for (const id of sourcesIds) {
+                const sourcePlace = (_a = this.cache.get(id)) === null || _a === void 0 ? void 0 : _a.place;
+                if (sourcePlace === undefined) {
+                    continue;
+                }
+                if (sourcePlace.identifier.name === null ||
+                    ((_b = sourcePlace.identifier.name) === null || _b === void 0 ? void 0 : _b.kind) === 'promoted') {
+                    newValue.sourcesIds.add(derivedVar.identifier.id);
+                }
+                else {
+                    newValue.sourcesIds.add(sourcePlace.identifier.id);
+                }
+            }
+        }
+        if (newValue.sourcesIds.size === 0) {
+            newValue.sourcesIds.add(derivedVar.identifier.id);
+        }
+        const existingValue = this.cache.get(derivedVar.identifier.id);
+        if (existingValue === undefined ||
+            !this.isDerivationEqual(existingValue, newValue)) {
+            this.cache.set(derivedVar.identifier.id, newValue);
+            this.hasChanges = true;
+        }
+    }
+    isDerivationEqual(a, b) {
+        if (a.typeOfValue !== b.typeOfValue) {
+            return false;
+        }
+        if (a.sourcesIds.size !== b.sourcesIds.size) {
+            return false;
+        }
+        for (const id of a.sourcesIds) {
+            if (!b.sourcesIds.has(id)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+function validateNoDerivedComputationsInEffects_exp(fn) {
+    const functions = new Map();
+    const derivationCache = new DerivationCache();
+    const errors = new CompilerError();
+    const effects = new Set();
+    const setStateCache = new Map();
+    const effectSetStateCache = new Map();
+    const context = {
+        functions,
+        errors,
+        derivationCache,
+        effects,
+        setStateCache,
+        effectSetStateCache,
+    };
+    if (fn.fnType === 'Hook') {
+        for (const param of fn.params) {
+            if (param.kind === 'Identifier') {
+                context.derivationCache.cache.set(param.identifier.id, {
+                    place: param,
+                    sourcesIds: new Set([param.identifier.id]),
+                    typeOfValue: 'fromProps',
+                });
+                context.derivationCache.hasChanges = true;
+            }
+        }
+    }
+    else if (fn.fnType === 'Component') {
+        const props = fn.params[0];
+        if (props != null && props.kind === 'Identifier') {
+            context.derivationCache.cache.set(props.identifier.id, {
+                place: props,
+                sourcesIds: new Set([props.identifier.id]),
+                typeOfValue: 'fromProps',
+            });
+            context.derivationCache.hasChanges = true;
+        }
+    }
+    let isFirstPass = true;
+    do {
+        for (const block of fn.body.blocks.values()) {
+            recordPhiDerivations(block, context);
+            for (const instr of block.instructions) {
+                recordInstructionDerivations(instr, context, isFirstPass);
+            }
+        }
+        isFirstPass = false;
+    } while (context.derivationCache.snapshot());
+    for (const effect of effects) {
+        validateEffect(effect, context);
+    }
+    if (errors.hasAnyErrors()) {
+        throw errors;
+    }
+}
+function recordPhiDerivations(block, context) {
+    for (const phi of block.phis) {
+        let typeOfValue = 'ignored';
+        let sourcesIds = new Set();
+        for (const operand of phi.operands.values()) {
+            const operandMetadata = context.derivationCache.cache.get(operand.identifier.id);
+            if (operandMetadata === undefined) {
+                continue;
+            }
+            typeOfValue = joinValue(typeOfValue, operandMetadata.typeOfValue);
+            sourcesIds.add(operand.identifier.id);
+        }
+        if (typeOfValue !== 'ignored') {
+            context.derivationCache.addDerivationEntry(phi.place, sourcesIds, typeOfValue);
+        }
+    }
+}
+function joinValue(lvalueType, valueType) {
+    if (lvalueType === 'ignored')
+        return valueType;
+    if (valueType === 'ignored')
+        return lvalueType;
+    if (lvalueType === valueType)
+        return lvalueType;
+    return 'fromPropsAndState';
+}
+function recordInstructionDerivations(instr, context, isFirstPass) {
+    let typeOfValue = 'ignored';
+    const sources = new Set();
+    const { lvalue, value } = instr;
+    if (value.kind === 'FunctionExpression') {
+        context.functions.set(lvalue.identifier.id, value);
+        for (const [, block] of value.loweredFunc.func.body.blocks) {
+            for (const instr of block.instructions) {
+                recordInstructionDerivations(instr, context, isFirstPass);
+            }
+        }
+    }
+    else if (value.kind === 'CallExpression' || value.kind === 'MethodCall') {
+        const callee = value.kind === 'CallExpression' ? value.callee : value.property;
+        if (isUseEffectHookType(callee.identifier) &&
+            value.args.length === 2 &&
+            value.args[0].kind === 'Identifier' &&
+            value.args[1].kind === 'Identifier') {
+            const effectFunction = context.functions.get(value.args[0].identifier.id);
+            if (effectFunction != null) {
+                context.effects.add(effectFunction.loweredFunc.func);
+            }
+        }
+        else if (isUseStateType(lvalue.identifier) && value.args.length > 0) {
+            const stateValueSource = value.args[0];
+            if (stateValueSource.kind === 'Identifier') {
+                sources.add(stateValueSource.identifier.id);
+            }
+            typeOfValue = joinValue(typeOfValue, 'fromState');
+        }
+    }
+    for (const operand of eachInstructionOperand(instr)) {
+        if (isSetStateType(operand.identifier) &&
+            operand.loc !== GeneratedSource &&
+            isFirstPass) {
+            if (context.setStateCache.has(operand.loc.identifierName)) {
+                context.setStateCache.get(operand.loc.identifierName).push(operand);
+            }
+            else {
+                context.setStateCache.set(operand.loc.identifierName, [operand]);
+            }
+        }
+        const operandMetadata = context.derivationCache.cache.get(operand.identifier.id);
+        if (operandMetadata === undefined) {
+            continue;
+        }
+        typeOfValue = joinValue(typeOfValue, operandMetadata.typeOfValue);
+        for (const id of operandMetadata.sourcesIds) {
+            sources.add(id);
+        }
+    }
+    if (typeOfValue === 'ignored') {
+        return;
+    }
+    for (const lvalue of eachInstructionLValue(instr)) {
+        context.derivationCache.addDerivationEntry(lvalue, sources, typeOfValue);
+    }
+    for (const operand of eachInstructionOperand(instr)) {
+        switch (operand.effect) {
+            case Effect.Capture:
+            case Effect.Store:
+            case Effect.ConditionallyMutate:
+            case Effect.ConditionallyMutateIterator:
+            case Effect.Mutate: {
+                if (isMutable(instr, operand)) {
+                    context.derivationCache.addDerivationEntry(operand, sources, typeOfValue);
+                }
+                break;
+            }
+            case Effect.Freeze:
+            case Effect.Read: {
+                break;
+            }
+            case Effect.Unknown: {
+                CompilerError.invariant(false, {
+                    reason: 'Unexpected unknown effect',
+                    description: null,
+                    details: [
+                        {
+                            kind: 'error',
+                            loc: operand.loc,
+                            message: 'Unexpected unknown effect',
+                        },
+                    ],
+                });
+            }
+            default: {
+                assertExhaustive$1(operand.effect, `Unexpected effect kind \`${operand.effect}\``);
+            }
+        }
+    }
+}
+function validateEffect(effectFunction, context) {
+    const seenBlocks = new Set();
+    const effectDerivedSetStateCalls = [];
+    const globals = new Set();
+    for (const block of effectFunction.body.blocks.values()) {
+        for (const pred of block.preds) {
+            if (!seenBlocks.has(pred)) {
+                return;
+            }
+        }
+        for (const instr of block.instructions) {
+            if (isUseRefType(instr.lvalue.identifier)) {
+                return;
+            }
+            for (const operand of eachInstructionOperand(instr)) {
+                if (isSetStateType(operand.identifier) &&
+                    operand.loc !== GeneratedSource) {
+                    if (context.effectSetStateCache.has(operand.loc.identifierName)) {
+                        context.effectSetStateCache
+                            .get(operand.loc.identifierName)
+                            .push(operand);
+                    }
+                    else {
+                        context.effectSetStateCache.set(operand.loc.identifierName, [
+                            operand,
+                        ]);
+                    }
+                }
+            }
+            if (instr.value.kind === 'CallExpression' &&
+                isSetStateType(instr.value.callee.identifier) &&
+                instr.value.args.length === 1 &&
+                instr.value.args[0].kind === 'Identifier') {
+                const argMetadata = context.derivationCache.cache.get(instr.value.args[0].identifier.id);
+                if (argMetadata !== undefined) {
+                    effectDerivedSetStateCalls.push({
+                        value: instr.value,
+                        loc: instr.value.callee.loc,
+                        sourceIds: argMetadata.sourcesIds,
+                        typeOfValue: argMetadata.typeOfValue,
+                    });
+                }
+            }
+            else if (instr.value.kind === 'CallExpression') {
+                const calleeMetadata = context.derivationCache.cache.get(instr.value.callee.identifier.id);
+                if (calleeMetadata !== undefined &&
+                    (calleeMetadata.typeOfValue === 'fromProps' ||
+                        calleeMetadata.typeOfValue === 'fromPropsAndState')) {
+                    return;
+                }
+                if (globals.has(instr.value.callee.identifier.id)) {
+                    return;
+                }
+            }
+            else if (instr.value.kind === 'LoadGlobal') {
+                globals.add(instr.lvalue.identifier.id);
+                for (const operand of eachInstructionOperand(instr)) {
+                    globals.add(operand.identifier.id);
+                }
+            }
+        }
+        seenBlocks.add(block.id);
+    }
+    for (const derivedSetStateCall of effectDerivedSetStateCalls) {
+        if (derivedSetStateCall.loc !== GeneratedSource &&
+            context.effectSetStateCache.has(derivedSetStateCall.loc.identifierName) &&
+            context.setStateCache.has(derivedSetStateCall.loc.identifierName) &&
+            context.effectSetStateCache.get(derivedSetStateCall.loc.identifierName)
+                .length ===
+                context.setStateCache.get(derivedSetStateCall.loc.identifierName)
+                    .length -
+                    1) {
+            const derivedDepsStr = Array.from(derivedSetStateCall.sourceIds)
+                .map(sourceId => {
+                var _a;
+                const sourceMetadata = context.derivationCache.cache.get(sourceId);
+                return (_a = sourceMetadata === null || sourceMetadata === void 0 ? void 0 : sourceMetadata.place.identifier.name) === null || _a === void 0 ? void 0 : _a.value;
+            })
+                .filter(Boolean)
+                .join(', ');
+            let description;
+            if (derivedSetStateCall.typeOfValue === 'fromProps') {
+                description = `From props: [${derivedDepsStr}]`;
+            }
+            else if (derivedSetStateCall.typeOfValue === 'fromState') {
+                description = `From local state: [${derivedDepsStr}]`;
+            }
+            else {
+                description = `From props and local state: [${derivedDepsStr}]`;
+            }
+            context.errors.pushDiagnostic(CompilerDiagnostic.create({
+                description: `Derived values (${description}) should be computed during render, rather than in effects. Using an effect triggers an additional render which can hurt performance and user experience, potentially briefly showing stale values to the user`,
+                category: ErrorCategory.EffectDerivationsOfState,
+                reason: 'You might not need an effect. Derive values in render, not effects.',
+            }).withDetails({
+                kind: 'error',
+                loc: derivedSetStateCall.value.callee.loc,
+                message: 'This should be computed during render, not in an effect',
+            }));
+        }
+    }
+}
+
 function nameAnonymousFunctions(fn) {
     if (fn.id == null) {
         return;
@@ -52231,6 +52752,9 @@ function runWithEnvironment(func, env) {
         if (env.config.validateNoDerivedComputationsInEffects) {
             validateNoDerivedComputationsInEffects(hir);
         }
+        if (env.config.validateNoDerivedComputationsInEffects_exp) {
+            validateNoDerivedComputationsInEffects_exp(hir);
+        }
         if (env.config.validateNoSetStateInEffects) {
             env.logErrors(validateNoSetStateInEffects(hir, env));
         }
@@ -53686,27 +54210,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',
@@ -53779,7 +54303,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,
                             });
@@ -53795,7 +54319,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,
                         });
@@ -53818,7 +54342,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,
         });
@@ -57332,6 +57856,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.'));
@@ -57631,6 +58159,7 @@ const rule = {
                 analyzer.leaveNode(node);
             },
             CallExpression(node) {
+                var _a, _b;
                 if (isHook(node.callee)) {
                     const reactHooksMap = last(codePathReactHooksMapStack);
                     const codePathSegment = last(codePathSegmentStack);
@@ -57647,6 +58176,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)) {