@sanity/cli-build 0.0.0-20260610102421 → 0.0.0-20260610123958

package/dist/_exports/_internal/build.d.ts

@@ -5,119 +5,11 @@ import { DefinedTelemetryTrace } from "@sanity/telemetry";
 import { FSWatcher } from "chokidar";
 import { InlineConfig } from "vite";
 import { InterfaceArtifact } from "@sanity/federation/vite";
-import { NodePath } from "@babel/core";
-import { NodePath as NodePath_2 } from "@babel/traverse";
 import { Output } from "@sanity/cli-core";
 import { Plugin as Plugin_2 } from "vite";
-import { Scope } from "@babel/traverse";
+import { PluginOptions } from "babel-plugin-react-compiler";
 import { ServiceArtifact } from "@sanity/federation/vite";
-import * as t from "@babel/types";
 import { UserViteConfig } from "@sanity/cli-core";
-import { z } from "zod";
-
-declare type AliasingEffect =
-  | {
-      kind: "Freeze";
-      value: Place;
-      reason: ValueReason;
-    }
-  | {
-      kind: "Mutate";
-      value: Place;
-      reason?: MutationReason | null;
-    }
-  | {
-      kind: "MutateConditionally";
-      value: Place;
-    }
-  | {
-      kind: "MutateTransitive";
-      value: Place;
-    }
-  | {
-      kind: "MutateTransitiveConditionally";
-      value: Place;
-    }
-  | {
-      kind: "Capture";
-      from: Place;
-      into: Place;
-    }
-  | {
-      kind: "Alias";
-      from: Place;
-      into: Place;
-    }
-  | {
-      kind: "MaybeAlias";
-      from: Place;
-      into: Place;
-    }
-  | {
-      kind: "Assign";
-      from: Place;
-      into: Place;
-    }
-  | {
-      kind: "Create";
-      into: Place;
-      value: ValueKind;
-      reason: ValueReason;
-    }
-  | {
-      kind: "CreateFrom";
-      from: Place;
-      into: Place;
-    }
-  | {
-      kind: "ImmutableCapture";
-      from: Place;
-      into: Place;
-    }
-  | {
-      kind: "Apply";
-      receiver: Place;
-      function: Place;
-      mutatesFunction: boolean;
-      args: Array<Place | SpreadPattern | Hole>;
-      into: Place;
-      signature: FunctionSignature | null;
-      loc: SourceLocation;
-    }
-  | {
-      kind: "CreateFunction";
-      captures: Array<Place>;
-      function: FunctionExpression | ObjectMethod;
-      into: Place;
-    }
-  | {
-      kind: "MutateFrozen";
-      place: Place;
-      error: CompilerDiagnostic;
-    }
-  | {
-      kind: "MutateGlobal";
-      place: Place;
-      error: CompilerDiagnostic;
-    }
-  | {
-      kind: "Impure";
-      place: Place;
-      error: CompilerDiagnostic;
-    }
-  | {
-      kind: "Render";
-      place: Place;
-    };
-
-declare type AliasingSignature = {
-  receiver: IdentifierId;
-  params: Array<IdentifierId>;
-  rest: IdentifierId | null;
-  returns: IdentifierId;
-  effects: Array<AliasingEffect>;
-  temporaries: Array<Place>;
-};
 
 export declare const AppBuildTrace: DefinedTelemetryTrace<
   {
@@ -126,59 +18,6 @@ export declare const AppBuildTrace: DefinedTelemetryTrace<
   void
 >;
 
-declare type ArrayExpression = {
-  kind: "ArrayExpression";
-  elements: Array<Place | SpreadPattern | Hole>;
-  loc: SourceLocation;
-};
-
-declare type ArrayPattern = {
-  kind: "ArrayPattern";
-  items: Array<Place | SpreadPattern | Hole>;
-};
-
-declare type AutoDepsDecorationsEvent = {
-  kind: "AutoDepsDecorations";
-  fnLoc: t.SourceLocation;
-  decorations: Array<t.SourceLocation>;
-};
-
-declare type AutoDepsEligibleEvent = {
-  kind: "AutoDepsEligible";
-  fnLoc: t.SourceLocation;
-  depArrayLoc: t.SourceLocation;
-};
-
-declare type BabelFn =
-  | NodePath<t.FunctionDeclaration>
-  | NodePath<t.FunctionExpression>
-  | NodePath<t.ArrowFunctionExpression>;
-
-declare type BasicBlock = {
-  kind: BlockKind;
-  id: BlockId;
-  instructions: Array<Instruction>;
-  terminal: Terminal;
-  preds: Set<BlockId>;
-  phis: Set<Phi>;
-};
-
-declare type BlockId = number & {
-  [opaqueBlockId]: "BlockId";
-};
-
-declare type BlockKind = "block" | "value" | "loop" | "sequence" | "catch";
-
-declare type BranchTerminal = {
-  kind: "branch";
-  test: Place;
-  consequent: BlockId;
-  alternate: BlockId;
-  id: InstructionId;
-  loc: SourceLocation;
-  fallthrough: BlockId;
-};
-
 export declare const buildDebug: Debugger;
 
 /**
@@ -192,27 +31,6 @@ export declare function buildVendorDependencies({
   outputDir,
 }: VendorBuildOptions): Promise<Record<string, string>>;
 
-declare type BuiltinTag = {
-  kind: "BuiltinTag";
-  name: string;
-  loc: SourceLocation;
-};
-
-declare type BuiltInType = PrimitiveType | FunctionType | ObjectType;
-
-declare type CallExpression = {
-  kind: "CallExpression";
-  callee: Place;
-  args: Array<Place | SpreadPattern>;
-  loc: SourceLocation;
-  typeArguments?: Array<t.FlowType>;
-};
-
-declare type Case = {
-  test: Place | null;
-  block: BlockId;
-};
-
 export declare function checkStudioDependencyVersions(
   workDir: string,
   output: Output,
@@ -223,308 +41,6 @@ export declare function checkStudioDependencyVersions(
   },
 ): Promise<void>;
 
-declare type CodegenFunction = {
-  type: "CodegenFunction";
-  id: t.Identifier | null;
-  nameHint: string | null;
-  params: t.FunctionDeclaration["params"];
-  body: t.BlockStatement;
-  generator: boolean;
-  async: boolean;
-  loc: SourceLocation;
-  memoSlotsUsed: number;
-  memoBlocks: number;
-  memoValues: number;
-  prunedMemoBlocks: number;
-  prunedMemoValues: number;
-  outlined: Array<{
-    fn: CodegenFunction;
-    type: ReactFunctionType | null;
-  }>;
-  hasInferredEffect: boolean;
-  inferredEffectLocations: Set<SourceLocation>;
-  hasFireRewrite: boolean;
-};
-
-declare type CompilationMode = z.infer<typeof CompilationModeSchema>;
-
-declare const CompilationModeSchema: z.ZodEnum<{
-  syntax: "syntax";
-  infer: "infer";
-  annotation: "annotation";
-  all: "all";
-}>;
-
-declare type CompileDiagnosticEvent = {
-  kind: "CompileDiagnostic";
-  fnLoc: t.SourceLocation | null;
-  detail: Omit<Omit<CompilerErrorDetailOptions, "severity">, "suggestions">;
-};
-
-declare type CompileErrorEvent = {
-  kind: "CompileError";
-  fnLoc: t.SourceLocation | null;
-  detail: CompilerErrorDetail | CompilerDiagnostic;
-};
-
-declare class CompilerDiagnostic {
-  options: CompilerDiagnosticOptions;
-  constructor(options: CompilerDiagnosticOptions);
-  static create(
-    options: Omit<CompilerDiagnosticOptions, "details">,
-  ): CompilerDiagnostic;
-  get reason(): CompilerDiagnosticOptions["reason"];
-  get description(): CompilerDiagnosticOptions["description"];
-  get severity(): ErrorSeverity;
-  get suggestions(): CompilerDiagnosticOptions["suggestions"];
-  get category(): ErrorCategory;
-  withDetails(...details: Array<CompilerDiagnosticDetail>): CompilerDiagnostic;
-  primaryLocation(): SourceLocation | null;
-  printErrorMessage(source: string, options: PrintErrorMessageOptions): string;
-  toString(): string;
-}
-
-declare type CompilerDiagnosticDetail =
-  | {
-      kind: "error";
-      loc: SourceLocation | null;
-      message: string | null;
-    }
-  | {
-      kind: "hint";
-      message: string;
-    };
-
-declare type CompilerDiagnosticOptions = {
-  category: ErrorCategory;
-  reason: string;
-  description: string | null;
-  details: Array<CompilerDiagnosticDetail>;
-  suggestions?: Array<CompilerSuggestion> | null | undefined;
-};
-
-declare class CompilerError extends Error {
-  details: Array<CompilerErrorDetail | CompilerDiagnostic>;
-  disabledDetails: Array<CompilerErrorDetail | CompilerDiagnostic>;
-  printedMessage: string | null;
-  static invariant(
-    condition: unknown,
-    options: Omit<CompilerDiagnosticOptions, "category">,
-  ): asserts condition;
-  static throwDiagnostic(options: CompilerDiagnosticOptions): never;
-  static throwTodo(
-    options: Omit<CompilerErrorDetailOptions, "category">,
-  ): never;
-  static throwInvalidJS(
-    options: Omit<CompilerErrorDetailOptions, "category">,
-  ): never;
-  static throwInvalidReact(options: CompilerErrorDetailOptions): never;
-  static throwInvalidConfig(
-    options: Omit<CompilerErrorDetailOptions, "category">,
-  ): never;
-  static throw(options: CompilerErrorDetailOptions): never;
-  constructor(...args: Array<any>);
-  get message(): string;
-  set message(_message: string);
-  toString(): string;
-  withPrintedMessage(
-    source: string,
-    options: PrintErrorMessageOptions,
-  ): CompilerError;
-  printErrorMessage(source: string, options: PrintErrorMessageOptions): string;
-  merge(other: CompilerError): void;
-  pushDiagnostic(diagnostic: CompilerDiagnostic): void;
-  push(options: CompilerErrorDetailOptions): CompilerErrorDetail;
-  pushErrorDetail(detail: CompilerErrorDetail): CompilerErrorDetail;
-  hasAnyErrors(): boolean;
-  asResult(): Result<void, CompilerError>;
-  hasErrors(): boolean;
-  hasWarning(): boolean;
-  hasHints(): boolean;
-}
-
-declare class CompilerErrorDetail {
-  options: CompilerErrorDetailOptions;
-  constructor(options: CompilerErrorDetailOptions);
-  get reason(): CompilerErrorDetailOptions["reason"];
-  get description(): CompilerErrorDetailOptions["description"];
-  get severity(): ErrorSeverity;
-  get loc(): CompilerErrorDetailOptions["loc"];
-  get suggestions(): CompilerErrorDetailOptions["suggestions"];
-  get category(): ErrorCategory;
-  primaryLocation(): SourceLocation | null;
-  printErrorMessage(source: string, options: PrintErrorMessageOptions): string;
-  toString(): string;
-}
-
-declare type CompilerErrorDetailOptions = {
-  category: ErrorCategory;
-  reason: string;
-  description?: string | null | undefined;
-  loc: SourceLocation | null;
-  suggestions?: Array<CompilerSuggestion> | null | undefined;
-};
-
-declare type CompilerMode = "all_features" | "no_inferred_memo";
-
-declare type CompilerPipelineValue =
-  | {
-      kind: "ast";
-      name: string;
-      value: CodegenFunction;
-    }
-  | {
-      kind: "hir";
-      name: string;
-      value: HIRFunction;
-    }
-  | {
-      kind: "reactive";
-      name: string;
-      value: ReactiveFunction;
-    }
-  | {
-      kind: "debug";
-      name: string;
-      value: string;
-    };
-
-declare type CompilerReactTarget = z.infer<typeof CompilerReactTargetSchema>;
-
-declare const CompilerReactTargetSchema: z.ZodUnion<
-  readonly [
-    z.ZodLiteral<"17">,
-    z.ZodLiteral<"18">,
-    z.ZodLiteral<"19">,
-    z.ZodObject<
-      {
-        kind: z.ZodLiteral<"donotuse_meta_internal">;
-        runtimeModule: z.ZodDefault<z.ZodString>;
-      },
-      z.core.$strip
-    >,
-  ]
->;
-
-declare type CompilerSuggestion =
-  | {
-      op:
-        | CompilerSuggestionOperation.InsertAfter
-        | CompilerSuggestionOperation.InsertBefore
-        | CompilerSuggestionOperation.Replace;
-      range: [number, number];
-      description: string;
-      text: string;
-    }
-  | {
-      op: CompilerSuggestionOperation.Remove;
-      range: [number, number];
-      description: string;
-    };
-
-declare enum CompilerSuggestionOperation {
-  InsertBefore = 0,
-  InsertAfter = 1,
-  Remove = 2,
-  Replace = 3,
-}
-
-declare type CompileSkipEvent = {
-  kind: "CompileSkip";
-  fnLoc: t.SourceLocation | null;
-  reason: string;
-  loc: t.SourceLocation | null;
-};
-
-declare type CompileSuccessEvent = {
-  kind: "CompileSuccess";
-  fnLoc: t.SourceLocation | null;
-  fnName: string | null;
-  memoSlots: number;
-  memoBlocks: number;
-  memoValues: number;
-  prunedMemoBlocks: number;
-  prunedMemoValues: number;
-};
-
-declare type ComponentType<T> = {
-  kind: "Component";
-  props: Map<string, T>;
-  children: null | T;
-};
-
-declare type ConcreteType<T> =
-  | {
-      kind: "Enum";
-    }
-  | {
-      kind: "Mixed";
-    }
-  | {
-      kind: "Number";
-    }
-  | {
-      kind: "String";
-    }
-  | {
-      kind: "Boolean";
-    }
-  | {
-      kind: "Void";
-    }
-  | {
-      kind: "Nullable";
-      type: T;
-    }
-  | {
-      kind: "Array";
-      element: T;
-    }
-  | {
-      kind: "Set";
-      element: T;
-    }
-  | {
-      kind: "Map";
-      key: T;
-      value: T;
-    }
-  | {
-      kind: "Function";
-      typeParameters: null | Array<TypeParameter<T>>;
-      params: Array<T>;
-      returnType: T;
-    }
-  | ComponentType<T>
-  | {
-      kind: "Generic";
-      id: TypeParameterId;
-      bound: T;
-    }
-  | {
-      kind: "Object";
-      id: NominalId;
-      members: Map<string, ResolvedType>;
-    }
-  | {
-      kind: "Tuple";
-      id: NominalId;
-      members: Array<T>;
-    }
-  | {
-      kind: "Structural";
-      id: LinearId;
-    }
-  | {
-      kind: "Union";
-      members: Array<T>;
-    }
-  | {
-      kind: "Instance";
-      name: string;
-      members: Map<string, ResolvedType>;
-    };
-
 /**
  * Copies a directory from one location to another
  *
@@ -540,387 +56,6 @@ export declare function copyDir(
   skipExisting?: boolean,
 ): Promise<void>;
 
-declare type CustomOptOutDirective = z.infer<
-  typeof CustomOptOutDirectiveSchema
->;
-
-declare const CustomOptOutDirectiveSchema: z.ZodDefault<
-  z.ZodNullable<z.ZodArray<z.ZodString>>
->;
-
-declare type DeclarationId = number & {
-  [opageDeclarationId]: "DeclarationId";
-};
-
-declare type DependencyPath = Array<DependencyPathEntry>;
-
-declare type DependencyPathEntry = {
-  property: PropertyLiteral;
-  optional: boolean;
-};
-
-declare type Destructure = {
-  kind: "Destructure";
-  lvalue: LValuePattern;
-  value: Place;
-  loc: SourceLocation;
-};
-
-declare type DoWhileTerminal = {
-  kind: "do-while";
-  loop: BlockId;
-  test: BlockId;
-  fallthrough: BlockId;
-  id: InstructionId;
-  loc: SourceLocation;
-};
-
-declare type DynamicGatingOptions = z.infer<typeof DynamicGatingOptionsSchema>;
-
-declare const DynamicGatingOptionsSchema: z.ZodObject<
-  {
-    source: z.ZodString;
-  },
-  z.core.$strip
->;
-
-declare enum Effect {
-  Unknown = "<unknown>",
-  Freeze = "freeze",
-  Read = "read",
-  Capture = "capture",
-  ConditionallyMutateIterator = "mutate-iterator?",
-  ConditionallyMutate = "mutate?",
-  Mutate = "mutate",
-  Store = "store",
-}
-
-declare class Environment {
-  #private;
-  logger: Logger | null;
-  filename: string | null;
-  code: string | null;
-  config: EnvironmentConfig;
-  fnType: ReactFunctionType;
-  compilerMode: CompilerMode;
-  programContext: ProgramContext;
-  hasFireRewrite: boolean;
-  hasInferredEffect: boolean;
-  inferredEffectLocations: Set<SourceLocation>;
-  parentFunction: NodePath_2<t.Function>;
-  constructor(
-    scope: Scope,
-    fnType: ReactFunctionType,
-    compilerMode: CompilerMode,
-    config: EnvironmentConfig,
-    contextIdentifiers: Set<t.Identifier>,
-    parentFunction: NodePath_2<t.Function>,
-    logger: Logger | null,
-    filename: string | null,
-    code: string | null,
-    programContext: ProgramContext,
-  );
-  get typeContext(): FlowTypeEnv;
-  get isInferredMemoEnabled(): boolean;
-  get nextIdentifierId(): IdentifierId;
-  get nextBlockId(): BlockId;
-  get nextScopeId(): ScopeId;
-  get scope(): Scope;
-  logErrors(errors: Result<void, CompilerError>): void;
-  isContextIdentifier(node: t.Identifier): boolean;
-  isHoistedIdentifier(node: t.Identifier): boolean;
-  generateGloballyUniqueIdentifierName(
-    name: string | null,
-  ): ValidatedIdentifier;
-  outlineFunction(fn: HIRFunction, type: ReactFunctionType | null): void;
-  getOutlinedFunctions(): Array<{
-    fn: HIRFunction;
-    type: ReactFunctionType | null;
-  }>;
-  getGlobalDeclaration(
-    binding: NonLocalBinding,
-    loc: SourceLocation,
-  ): Global_2 | null;
-  static knownReactModules: ReadonlyArray<string>;
-  getFallthroughPropertyType(
-    receiver: Type,
-    _property: Type,
-  ): BuiltInType | PolyType | null;
-  getPropertyType(
-    receiver: Type,
-    property: string | number,
-  ): BuiltInType | PolyType | null;
-  getFunctionSignature(type: FunctionType): FunctionSignature | null;
-  addHoistedIdentifier(node: t.Identifier): void;
-}
-
-declare type EnvironmentConfig = z.infer<typeof EnvironmentConfigSchema>;
-
-declare const EnvironmentConfigSchema: z.ZodObject<
-  {
-    customHooks: z.ZodDefault<
-      z.ZodMap<
-        z.ZodString,
-        z.ZodObject<
-          {
-            effectKind: z.ZodEnum<typeof Effect>;
-            valueKind: z.ZodEnum<typeof ValueKind>;
-            noAlias: z.ZodDefault<z.ZodBoolean>;
-            transitiveMixedData: z.ZodDefault<z.ZodBoolean>;
-          },
-          z.core.$strip
-        >
-      >
-    >;
-    moduleTypeProvider: z.ZodDefault<z.ZodNullable<z.ZodAny>>;
-    customMacros: z.ZodDefault<
-      z.ZodNullable<
-        z.ZodArray<
-          z.ZodUnion<
-            readonly [
-              z.ZodString,
-              z.ZodTuple<
-                [
-                  z.ZodString,
-                  z.ZodArray<
-                    z.ZodUnion<
-                      readonly [
-                        z.ZodObject<
-                          {
-                            type: z.ZodLiteral<"wildcard">;
-                          },
-                          z.core.$strip
-                        >,
-                        z.ZodObject<
-                          {
-                            type: z.ZodLiteral<"name">;
-                            name: z.ZodString;
-                          },
-                          z.core.$strip
-                        >,
-                      ]
-                    >
-                  >,
-                ],
-                null
-              >,
-            ]
-          >
-        >
-      >
-    >;
-    enableResetCacheOnSourceFileChanges: z.ZodDefault<
-      z.ZodNullable<z.ZodBoolean>
-    >;
-    enablePreserveExistingMemoizationGuarantees: z.ZodDefault<z.ZodBoolean>;
-    validatePreserveExistingMemoizationGuarantees: z.ZodDefault<z.ZodBoolean>;
-    enablePreserveExistingManualUseMemo: z.ZodDefault<z.ZodBoolean>;
-    enableForest: z.ZodDefault<z.ZodBoolean>;
-    enableUseTypeAnnotations: z.ZodDefault<z.ZodBoolean>;
-    flowTypeProvider: z.ZodDefault<z.ZodNullable<z.ZodAny>>;
-    enableOptionalDependencies: z.ZodDefault<z.ZodBoolean>;
-    enableFire: z.ZodDefault<z.ZodBoolean>;
-    enableNameAnonymousFunctions: z.ZodDefault<z.ZodBoolean>;
-    inferEffectDependencies: z.ZodDefault<
-      z.ZodNullable<
-        z.ZodArray<
-          z.ZodObject<
-            {
-              function: z.ZodObject<
-                {
-                  source: z.ZodString;
-                  importSpecifierName: z.ZodString;
-                },
-                z.core.$strip
-              >;
-              autodepsIndex: z.ZodNumber;
-            },
-            z.core.$strip
-          >
-        >
-      >
-    >;
-    inlineJsxTransform: z.ZodDefault<
-      z.ZodNullable<
-        z.ZodObject<
-          {
-            elementSymbol: z.ZodUnion<
-              readonly [
-                z.ZodLiteral<"react.element">,
-                z.ZodLiteral<"react.transitional.element">,
-              ]
-            >;
-            globalDevVar: z.ZodString;
-          },
-          z.core.$strip
-        >
-      >
-    >;
-    validateHooksUsage: z.ZodDefault<z.ZodBoolean>;
-    validateRefAccessDuringRender: z.ZodDefault<z.ZodBoolean>;
-    validateNoSetStateInRender: z.ZodDefault<z.ZodBoolean>;
-    validateNoSetStateInEffects: z.ZodDefault<z.ZodBoolean>;
-    validateNoDerivedComputationsInEffects: z.ZodDefault<z.ZodBoolean>;
-    validateNoJSXInTryStatements: z.ZodDefault<z.ZodBoolean>;
-    validateStaticComponents: z.ZodDefault<z.ZodBoolean>;
-    validateMemoizedEffectDependencies: z.ZodDefault<z.ZodBoolean>;
-    validateNoCapitalizedCalls: z.ZodDefault<
-      z.ZodNullable<z.ZodArray<z.ZodString>>
-    >;
-    validateBlocklistedImports: z.ZodDefault<
-      z.ZodNullable<z.ZodArray<z.ZodString>>
-    >;
-    validateNoImpureFunctionsInRender: z.ZodDefault<z.ZodBoolean>;
-    validateNoFreezingKnownMutableFunctions: z.ZodDefault<z.ZodBoolean>;
-    enableAssumeHooksFollowRulesOfReact: z.ZodDefault<z.ZodBoolean>;
-    enableTransitivelyFreezeFunctionExpressions: z.ZodDefault<z.ZodBoolean>;
-    enableEmitFreeze: z.ZodDefault<
-      z.ZodNullable<
-        z.ZodObject<
-          {
-            source: z.ZodString;
-            importSpecifierName: z.ZodString;
-          },
-          z.core.$strip
-        >
-      >
-    >;
-    enableEmitHookGuards: z.ZodDefault<
-      z.ZodNullable<
-        z.ZodObject<
-          {
-            source: z.ZodString;
-            importSpecifierName: z.ZodString;
-          },
-          z.core.$strip
-        >
-      >
-    >;
-    enableInstructionReordering: z.ZodDefault<z.ZodBoolean>;
-    enableFunctionOutlining: z.ZodDefault<z.ZodBoolean>;
-    enableJsxOutlining: z.ZodDefault<z.ZodBoolean>;
-    enableEmitInstrumentForget: z.ZodDefault<
-      z.ZodNullable<
-        z.ZodObject<
-          {
-            fn: z.ZodObject<
-              {
-                source: z.ZodString;
-                importSpecifierName: z.ZodString;
-              },
-              z.core.$strip
-            >;
-            gating: z.ZodNullable<
-              z.ZodObject<
-                {
-                  source: z.ZodString;
-                  importSpecifierName: z.ZodString;
-                },
-                z.core.$strip
-              >
-            >;
-            globalGating: z.ZodNullable<z.ZodString>;
-          },
-          z.core.$strip
-        >
-      >
-    >;
-    assertValidMutableRanges: z.ZodDefault<z.ZodBoolean>;
-    enableChangeVariableCodegen: z.ZodDefault<z.ZodBoolean>;
-    enableMemoizationComments: z.ZodDefault<z.ZodBoolean>;
-    throwUnknownException__testonly: z.ZodDefault<z.ZodBoolean>;
-    enableTreatFunctionDepsAsConditional: z.ZodDefault<z.ZodBoolean>;
-    disableMemoizationForDebugging: z.ZodDefault<z.ZodBoolean>;
-    enableChangeDetectionForDebugging: z.ZodDefault<
-      z.ZodNullable<
-        z.ZodObject<
-          {
-            source: z.ZodString;
-            importSpecifierName: z.ZodString;
-          },
-          z.core.$strip
-        >
-      >
-    >;
-    enableCustomTypeDefinitionForReanimated: z.ZodDefault<z.ZodBoolean>;
-    hookPattern: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-    enableTreatRefLikeIdentifiersAsRefs: z.ZodDefault<z.ZodBoolean>;
-    enableTreatSetIdentifiersAsStateSetters: z.ZodDefault<z.ZodBoolean>;
-    lowerContextAccess: z.ZodDefault<
-      z.ZodNullable<
-        z.ZodObject<
-          {
-            source: z.ZodString;
-            importSpecifierName: z.ZodString;
-          },
-          z.core.$strip
-        >
-      >
-    >;
-    validateNoVoidUseMemo: z.ZodDefault<z.ZodBoolean>;
-    validateNoDynamicallyCreatedComponentsOrHooks: z.ZodDefault<z.ZodBoolean>;
-    enableAllowSetStateFromRefsInEffects: z.ZodDefault<z.ZodBoolean>;
-  },
-  z.core.$strip
->;
-
-declare class ErrImpl<E> implements Result<never, E> {
-  #private;
-  constructor(val: E);
-  map<U>(_fn: (val: never) => U): Result<U, E>;
-  mapErr<F>(fn: (val: E) => F): Result<never, F>;
-  mapOr<U>(fallback: U, _fn: (val: never) => U): U;
-  mapOrElse<U>(fallback: () => U, _fn: (val: never) => U): U;
-  andThen<U>(_fn: (val: never) => Result<U, E>): Result<U, E>;
-  and<U>(_res: Result<U, E>): Result<U, E>;
-  or(res: Result<never, E>): Result<never, E>;
-  orElse<F>(fn: (val: E) => ErrImpl<F>): Result<never, F>;
-  isOk(): this is OkImpl<never>;
-  isErr(): this is ErrImpl<E>;
-  expect(msg: string): never;
-  expectErr(_msg: string): E;
-  unwrap(): never;
-  unwrapOr<T>(fallback: T): T;
-  unwrapOrElse<T>(fallback: (val: E) => T): T;
-  unwrapErr(): E;
-}
-
-declare enum ErrorCategory {
-  Hooks = "Hooks",
-  CapitalizedCalls = "CapitalizedCalls",
-  StaticComponents = "StaticComponents",
-  UseMemo = "UseMemo",
-  Factories = "Factories",
-  PreserveManualMemo = "PreserveManualMemo",
-  IncompatibleLibrary = "IncompatibleLibrary",
-  Immutability = "Immutability",
-  Globals = "Globals",
-  Refs = "Refs",
-  EffectDependencies = "EffectDependencies",
-  EffectSetState = "EffectSetState",
-  EffectDerivationsOfState = "EffectDerivationsOfState",
-  ErrorBoundaries = "ErrorBoundaries",
-  Purity = "Purity",
-  RenderSetState = "RenderSetState",
-  Invariant = "Invariant",
-  Todo = "Todo",
-  Syntax = "Syntax",
-  UnsupportedSyntax = "UnsupportedSyntax",
-  Config = "Config",
-  Gating = "Gating",
-  Suppression = "Suppression",
-  AutomaticEffectDependencies = "AutomaticEffectDependencies",
-  Fire = "Fire",
-  FBT = "FBT",
-}
-
-declare enum ErrorSeverity {
-  Error = "Error",
-  Warning = "Warning",
-  Hint = "Hint",
-  Off = "Off",
-}
-
 /**
  * Merge user-provided Vite configuration object or function
  *
@@ -935,16 +70,6 @@ export declare function extendViteConfigWithUserConfig(
   userConfig: UserViteConfig,
 ): Promise<InlineConfig>;
 
-declare type ExternalFunction = z.infer<typeof ExternalFunctionSchema>;
-
-declare const ExternalFunctionSchema: z.ZodObject<
-  {
-    source: z.ZodString;
-    importSpecifierName: z.ZodString;
-  },
-  z.core.$strip
->;
-
 /**
  * Ensure Sanity entry chunk is always loaded
  *
@@ -956,98 +81,6 @@ export declare function finalizeViteConfig(
   config: InlineConfig,
 ): Promise<InlineConfig>;
 
-declare type FinishMemoize = {
-  kind: "FinishMemoize";
-  manualMemoId: number;
-  decl: Place;
-  pruned?: true;
-  loc: SourceLocation;
-};
-
-declare class FlowTypeEnv implements ITypeEnv {
-  #private;
-  moduleEnv: Map<string, ResolvedType>;
-  init(env: Environment, source: string): void;
-  setType(identifier: Identifier, type: ResolvedType): void;
-  getType(identifier: Identifier): ResolvedType;
-  getTypeOrNull(identifier: Identifier): ResolvedType | null;
-  getTypeByLoc(loc: SourceLocation): ResolvedType | null;
-  nextNominalId(): NominalId;
-  nextTypeParameterId(): TypeParameterId;
-  addBinding(bindingIdentifier: t.Identifier, type: ResolvedType): void;
-  resolveBinding(bindingIdentifier: t.Identifier): ResolvedType | null;
-  pushGeneric(name: string, generic: TypeParameter<ResolvedType>): void;
-  popGeneric(name: string): void;
-  getGeneric(name: string): null | TypeParameter<ResolvedType>;
-}
-
-declare type ForInTerminal = {
-  kind: "for-in";
-  loc: SourceLocation;
-  init: BlockId;
-  loop: BlockId;
-  fallthrough: BlockId;
-  id: InstructionId;
-};
-
-declare type ForOfTerminal = {
-  kind: "for-of";
-  loc: SourceLocation;
-  init: BlockId;
-  test: BlockId;
-  loop: BlockId;
-  fallthrough: BlockId;
-  id: InstructionId;
-};
-
-declare type ForTerminal = {
-  kind: "for";
-  loc: SourceLocation;
-  init: BlockId;
-  test: BlockId;
-  update: BlockId | null;
-  loop: BlockId;
-  fallthrough: BlockId;
-  id: InstructionId;
-};
-
-declare type FunctionExpression = {
-  kind: "FunctionExpression";
-  name: ValidIdentifierName | null;
-  nameHint: string | null;
-  loweredFunc: LoweredFunction;
-  type:
-    | "ArrowFunctionExpression"
-    | "FunctionExpression"
-    | "FunctionDeclaration";
-  loc: SourceLocation;
-};
-
-declare type FunctionSignature = {
-  positionalParams: Array<Effect>;
-  restParam: Effect | null;
-  returnType: BuiltInType | PolyType;
-  returnValueKind: ValueKind;
-  returnValueReason?: ValueReason;
-  calleeEffect: Effect;
-  hookKind: HookKind | null;
-  noAlias?: boolean;
-  mutableOnlyIfOperandsAreMutable?: boolean;
-  impure?: boolean;
-  knownIncompatible?: string | null | undefined;
-  canonicalName?: string;
-  aliasing?: AliasingSignature | null | undefined;
-};
-
-declare type FunctionType = {
-  kind: "Function";
-  shapeId: string | null;
-  return: Type;
-  isConstructor: boolean;
-};
-
-declare const GeneratedSource: unique symbol;
-
 /**
  * Get a configuration object for Vite based on the passed options
  *
@@ -1057,1034 +90,6 @@ export declare function getViteConfig(
   options: ViteOptions,
 ): Promise<InlineConfig>;
 
-declare type Global_2 = BuiltInType | PolyType;
-
-declare type GotoTerminal = {
-  kind: "goto";
-  block: BlockId;
-  variant: GotoVariant;
-  id: InstructionId;
-  loc: SourceLocation;
-  fallthrough?: never;
-};
-
-declare enum GotoVariant {
-  Break = "Break",
-  Continue = "Continue",
-  Try = "Try",
-}
-
-declare type HIR = {
-  entry: BlockId;
-  blocks: Map<BlockId, BasicBlock>;
-};
-
-declare type HIRFunction = {
-  loc: SourceLocation;
-  id: ValidIdentifierName | null;
-  nameHint: string | null;
-  fnType: ReactFunctionType;
-  env: Environment;
-  params: Array<Place | SpreadPattern>;
-  returnTypeAnnotation: t.FlowType | t.TSType | null;
-  returns: Place;
-  context: Array<Place>;
-  body: HIR;
-  generator: boolean;
-  async: boolean;
-  directives: Array<string>;
-  aliasingEffects: Array<AliasingEffect> | null;
-};
-
-declare type Hole = {
-  kind: "Hole";
-};
-
-declare type HookKind =
-  | "useContext"
-  | "useState"
-  | "useActionState"
-  | "useReducer"
-  | "useRef"
-  | "useEffect"
-  | "useLayoutEffect"
-  | "useInsertionEffect"
-  | "useMemo"
-  | "useCallback"
-  | "useTransition"
-  | "useImperativeHandle"
-  | "useEffectEvent"
-  | "Custom";
-
-declare type Identifier = {
-  id: IdentifierId;
-  declarationId: DeclarationId;
-  name: IdentifierName | null;
-  mutableRange: MutableRange;
-  scope: ReactiveScope | null;
-  type: Type;
-  loc: SourceLocation;
-};
-
-declare type IdentifierId = number & {
-  [opaqueIdentifierId]: "IdentifierId";
-};
-
-declare type IdentifierName = ValidatedIdentifier | PromotedIdentifier;
-
-declare type IfTerminal = {
-  kind: "if";
-  test: Place;
-  consequent: BlockId;
-  alternate: BlockId;
-  fallthrough: BlockId;
-  id: InstructionId;
-  loc: SourceLocation;
-};
-
-declare type Instruction = {
-  id: InstructionId;
-  lvalue: Place;
-  value: InstructionValue;
-  loc: SourceLocation;
-  effects: Array<AliasingEffect> | null;
-};
-
-declare type InstructionId = number & {
-  [opaqueInstructionId]: "IdentifierId";
-};
-
-declare enum InstructionKind {
-  Const = "Const",
-  Let = "Let",
-  Reassign = "Reassign",
-  Catch = "Catch",
-  HoistedConst = "HoistedConst",
-  HoistedLet = "HoistedLet",
-  HoistedFunction = "HoistedFunction",
-  Function = "Function",
-}
-
-declare type InstructionValue =
-  | LoadLocal
-  | LoadContext
-  | {
-      kind: "DeclareLocal";
-      lvalue: LValue;
-      type: t.FlowType | t.TSType | null;
-      loc: SourceLocation;
-    }
-  | {
-      kind: "DeclareContext";
-      lvalue: {
-        kind:
-          | InstructionKind.Let
-          | InstructionKind.HoistedConst
-          | InstructionKind.HoistedLet
-          | InstructionKind.HoistedFunction;
-        place: Place;
-      };
-      loc: SourceLocation;
-    }
-  | StoreLocal
-  | {
-      kind: "StoreContext";
-      lvalue: {
-        kind:
-          | InstructionKind.Reassign
-          | InstructionKind.Const
-          | InstructionKind.Let
-          | InstructionKind.Function;
-        place: Place;
-      };
-      value: Place;
-      loc: SourceLocation;
-    }
-  | Destructure
-  | {
-      kind: "Primitive";
-      value: number | boolean | string | null | undefined;
-      loc: SourceLocation;
-    }
-  | JSXText
-  | {
-      kind: "BinaryExpression";
-      operator: Exclude<t.BinaryExpression["operator"], "|>">;
-      left: Place;
-      right: Place;
-      loc: SourceLocation;
-    }
-  | NewExpression
-  | CallExpression
-  | MethodCall
-  | {
-      kind: "UnaryExpression";
-      operator: Exclude<t.UnaryExpression["operator"], "throw" | "delete">;
-      value: Place;
-      loc: SourceLocation;
-    }
-  | ({
-      kind: "TypeCastExpression";
-      value: Place;
-      type: Type;
-      loc: SourceLocation;
-    } & (
-      | {
-          typeAnnotation: t.FlowType;
-          typeAnnotationKind: "cast";
-        }
-      | {
-          typeAnnotation: t.TSType;
-          typeAnnotationKind: "as" | "satisfies";
-        }
-    ))
-  | JsxExpression
-  | {
-      kind: "ObjectExpression";
-      properties: Array<ObjectProperty | SpreadPattern>;
-      loc: SourceLocation;
-    }
-  | ObjectMethod
-  | ArrayExpression
-  | {
-      kind: "JsxFragment";
-      children: Array<Place>;
-      loc: SourceLocation;
-    }
-  | {
-      kind: "RegExpLiteral";
-      pattern: string;
-      flags: string;
-      loc: SourceLocation;
-    }
-  | {
-      kind: "MetaProperty";
-      meta: string;
-      property: string;
-      loc: SourceLocation;
-    }
-  | {
-      kind: "PropertyStore";
-      object: Place;
-      property: PropertyLiteral;
-      value: Place;
-      loc: SourceLocation;
-    }
-  | PropertyLoad
-  | {
-      kind: "PropertyDelete";
-      object: Place;
-      property: PropertyLiteral;
-      loc: SourceLocation;
-    }
-  | {
-      kind: "ComputedStore";
-      object: Place;
-      property: Place;
-      value: Place;
-      loc: SourceLocation;
-    }
-  | {
-      kind: "ComputedLoad";
-      object: Place;
-      property: Place;
-      loc: SourceLocation;
-    }
-  | {
-      kind: "ComputedDelete";
-      object: Place;
-      property: Place;
-      loc: SourceLocation;
-    }
-  | LoadGlobal
-  | StoreGlobal
-  | FunctionExpression
-  | {
-      kind: "TaggedTemplateExpression";
-      tag: Place;
-      value: {
-        raw: string;
-        cooked?: string;
-      };
-      loc: SourceLocation;
-    }
-  | {
-      kind: "TemplateLiteral";
-      subexprs: Array<Place>;
-      quasis: Array<{
-        raw: string;
-        cooked?: string;
-      }>;
-      loc: SourceLocation;
-    }
-  | {
-      kind: "Await";
-      value: Place;
-      loc: SourceLocation;
-    }
-  | {
-      kind: "GetIterator";
-      collection: Place;
-      loc: SourceLocation;
-    }
-  | {
-      kind: "IteratorNext";
-      iterator: Place;
-      collection: Place;
-      loc: SourceLocation;
-    }
-  | {
-      kind: "NextPropertyOf";
-      value: Place;
-      loc: SourceLocation;
-    }
-  | {
-      kind: "PrefixUpdate";
-      lvalue: Place;
-      operation: t.UpdateExpression["operator"];
-      value: Place;
-      loc: SourceLocation;
-    }
-  | {
-      kind: "PostfixUpdate";
-      lvalue: Place;
-      operation: t.UpdateExpression["operator"];
-      value: Place;
-      loc: SourceLocation;
-    }
-  | {
-      kind: "Debugger";
-      loc: SourceLocation;
-    }
-  | StartMemoize
-  | FinishMemoize
-  | {
-      kind: "UnsupportedNode";
-      node: t.Node;
-      loc: SourceLocation;
-    };
-
-declare interface ITypeEnv {
-  popGeneric(name: string): void;
-  getGeneric(name: string): null | TypeParameter<ResolvedType>;
-  pushGeneric(
-    name: string,
-    binding: {
-      name: string;
-      id: TypeParameterId;
-      bound: ResolvedType;
-    },
-  ): void;
-  getType(id: Identifier): ResolvedType;
-  getTypeOrNull(id: Identifier): ResolvedType | null;
-  setType(id: Identifier, type: ResolvedType): void;
-  nextNominalId(): NominalId;
-  nextTypeParameterId(): TypeParameterId;
-  moduleEnv: Map<string, ResolvedType>;
-  addBinding(bindingIdentifier: t.Identifier, type: ResolvedType): void;
-  resolveBinding(bindingIdentifier: t.Identifier): ResolvedType | null;
-}
-
-declare type JsxAttribute =
-  | {
-      kind: "JsxSpreadAttribute";
-      argument: Place;
-    }
-  | {
-      kind: "JsxAttribute";
-      name: string;
-      place: Place;
-    };
-
-declare type JsxExpression = {
-  kind: "JsxExpression";
-  tag: Place | BuiltinTag;
-  props: Array<JsxAttribute>;
-  children: Array<Place> | null;
-  loc: SourceLocation;
-  openingLoc: SourceLocation;
-  closingLoc: SourceLocation;
-};
-
-declare type JSXText = {
-  kind: "JSXText";
-  value: string;
-  loc: SourceLocation;
-};
-
-declare type LabelTerminal = {
-  kind: "label";
-  block: BlockId;
-  fallthrough: BlockId;
-  id: InstructionId;
-  loc: SourceLocation;
-};
-
-declare type LinearId = number & {
-  [opaqueLinearId]: "LinearId";
-};
-
-declare type LoadContext = {
-  kind: "LoadContext";
-  place: Place;
-  loc: SourceLocation;
-};
-
-declare type LoadGlobal = {
-  kind: "LoadGlobal";
-  binding: NonLocalBinding;
-  loc: SourceLocation;
-};
-
-declare type LoadLocal = {
-  kind: "LoadLocal";
-  place: Place;
-  loc: SourceLocation;
-};
-
-declare type Logger = {
-  logEvent: (filename: string | null, event: LoggerEvent) => void;
-  debugLogIRs?: (value: CompilerPipelineValue) => void;
-};
-
-declare type LoggerEvent =
-  | CompileSuccessEvent
-  | CompileErrorEvent
-  | CompileDiagnosticEvent
-  | CompileSkipEvent
-  | PipelineErrorEvent
-  | TimingEvent
-  | AutoDepsDecorationsEvent
-  | AutoDepsEligibleEvent;
-
-declare type LogicalTerminal = {
-  kind: "logical";
-  operator: t.LogicalExpression["operator"];
-  test: BlockId;
-  fallthrough: BlockId;
-  id: InstructionId;
-  loc: SourceLocation;
-};
-
-declare type LoweredFunction = {
-  func: HIRFunction;
-};
-
-declare type LValue = {
-  place: Place;
-  kind: InstructionKind;
-};
-
-declare type LValuePattern = {
-  pattern: Pattern;
-  kind: InstructionKind;
-};
-
-declare type ManualMemoDependency = {
-  root:
-    | {
-        kind: "NamedLocal";
-        value: Place;
-      }
-    | {
-        kind: "Global";
-        identifierName: string;
-      };
-  path: DependencyPath;
-};
-
-declare type MaybeThrowTerminal = {
-  kind: "maybe-throw";
-  continuation: BlockId;
-  handler: BlockId;
-  id: InstructionId;
-  loc: SourceLocation;
-  fallthrough?: never;
-  effects: Array<AliasingEffect> | null;
-};
-
-declare type MethodCall = {
-  kind: "MethodCall";
-  receiver: Place;
-  property: Place;
-  args: Array<Place | SpreadPattern>;
-  loc: SourceLocation;
-};
-
-declare type MutableRange = {
-  start: InstructionId;
-  end: InstructionId;
-};
-
-declare type MutationReason = {
-  kind: "AssignCurrentProperty";
-};
-
-declare type NewExpression = {
-  kind: "NewExpression";
-  callee: Place;
-  args: Array<Place | SpreadPattern>;
-  loc: SourceLocation;
-};
-
-declare type NominalId = number & {
-  [opaqueNominalId]: "NominalId";
-};
-
-declare type NonLocalBinding =
-  | {
-      kind: "ImportDefault";
-      name: string;
-      module: string;
-    }
-  | {
-      kind: "ImportNamespace";
-      name: string;
-      module: string;
-    }
-  | NonLocalImportSpecifier
-  | {
-      kind: "ModuleLocal";
-      name: string;
-    }
-  | {
-      kind: "Global";
-      name: string;
-    };
-
-declare type NonLocalImportSpecifier = {
-  kind: "ImportSpecifier";
-  name: string;
-  module: string;
-  imported: string;
-};
-
-declare type ObjectMethod$1 = {
-  kind: "ObjectMethod";
-};
-
-declare type ObjectMethod = {
-  kind: "ObjectMethod";
-  loc: SourceLocation;
-  loweredFunc: LoweredFunction;
-};
-
-declare type ObjectPattern = {
-  kind: "ObjectPattern";
-  properties: Array<ObjectProperty | SpreadPattern>;
-};
-
-declare type ObjectProperty = {
-  kind: "ObjectProperty";
-  key: ObjectPropertyKey;
-  type: "property" | "method";
-  place: Place;
-};
-
-declare type ObjectPropertyKey =
-  | {
-      kind: "string";
-      name: string;
-    }
-  | {
-      kind: "identifier";
-      name: string;
-    }
-  | {
-      kind: "computed";
-      name: Place;
-    }
-  | {
-      kind: "number";
-      name: number;
-    };
-
-declare type ObjectType = {
-  kind: "Object";
-  shapeId: string | null;
-};
-
-declare class OkImpl<T> implements Result<T, never> {
-  #private;
-  constructor(val: T);
-  map<U>(fn: (val: T) => U): Result<U, never>;
-  mapErr<F>(_fn: (val: never) => F): Result<T, F>;
-  mapOr<U>(_fallback: U, fn: (val: T) => U): U;
-  mapOrElse<U>(_fallback: () => U, fn: (val: T) => U): U;
-  andThen<U>(fn: (val: T) => Result<U, never>): Result<U, never>;
-  and<U>(res: Result<U, never>): Result<U, never>;
-  or(_res: Result<T, never>): Result<T, never>;
-  orElse<F>(_fn: (val: never) => Result<T, F>): Result<T, F>;
-  isOk(): this is OkImpl<T>;
-  isErr(): this is ErrImpl<never>;
-  expect(_msg: string): T;
-  expectErr(msg: string): never;
-  unwrap(): T;
-  unwrapOr(_fallback: T): T;
-  unwrapOrElse(_fallback: (val: never) => T): T;
-  unwrapErr(): never;
-}
-
-declare const opageDeclarationId: unique symbol;
-
-declare const opaqueBlockId: unique symbol;
-
-declare const opaqueIdentifierId: unique symbol;
-
-declare const opaqueInstructionId: unique symbol;
-
-declare const opaqueLinearId: unique symbol;
-
-declare const opaqueNominalId: unique symbol;
-
-declare const opaquePropertyLiteral: unique symbol;
-
-declare const opaqueScopeId: unique symbol;
-
-declare const opaqueTypeId: unique symbol;
-
-declare const opaqueTypeParameterId: unique symbol;
-
-declare const opaqueValidIdentifierName: unique symbol;
-
-declare type OptionalTerminal = {
-  kind: "optional";
-  optional: boolean;
-  test: BlockId;
-  fallthrough: BlockId;
-  id: InstructionId;
-  loc: SourceLocation;
-};
-
-declare type PanicThresholdOptions = z.infer<
-  typeof PanicThresholdOptionsSchema
->;
-
-declare const PanicThresholdOptionsSchema: z.ZodEnum<{
-  none: "none";
-  all_errors: "all_errors";
-  critical_errors: "critical_errors";
-}>;
-
-declare type ParsedPluginOptions = Required<
-  Omit<PluginOptions, "environment">
-> & {
-  environment: EnvironmentConfig;
-};
-
-declare type Pattern = ArrayPattern | ObjectPattern;
-
-declare type Phi = {
-  kind: "Phi";
-  place: Place;
-  operands: Map<BlockId, Place>;
-};
-
-declare type PhiType = {
-  kind: "Phi";
-  operands: Array<Type>;
-};
-
-declare type PipelineErrorEvent = {
-  kind: "PipelineError";
-  fnLoc: t.SourceLocation | null;
-  data: string;
-};
-
-declare type Place = {
-  kind: "Identifier";
-  identifier: Identifier;
-  effect: Effect;
-  reactive: boolean;
-  loc: SourceLocation;
-};
-
-declare type Platform = "client" | "server" | "shared";
-
-declare type PluginOptions = Partial<{
-  environment: Partial<EnvironmentConfig>;
-  logger: Logger | null;
-  gating: ExternalFunction | null;
-  dynamicGating: DynamicGatingOptions | null;
-  panicThreshold: PanicThresholdOptions;
-  noEmit: boolean;
-  compilationMode: CompilationMode;
-  eslintSuppressionRules: Array<string> | null | undefined;
-  flowSuppressions: boolean;
-  ignoreUseNoForget: boolean;
-  customOptOutDirectives: CustomOptOutDirective;
-  sources: Array<string> | ((filename: string) => boolean) | null;
-  enableReanimatedCheck: boolean;
-  target: CompilerReactTarget;
-}>;
-
-declare type PolyType = {
-  kind: "Poly";
-};
-
-declare type PrimitiveType = {
-  kind: "Primitive";
-};
-
-declare type PrintErrorMessageOptions = {
-  eslint: boolean;
-};
-
-declare class ProgramContext {
-  scope: Scope;
-  opts: ParsedPluginOptions;
-  filename: string | null;
-  code: string | null;
-  reactRuntimeModule: string;
-  suppressions: Array<SuppressionRange>;
-  hasModuleScopeOptOut: boolean;
-  alreadyCompiled: WeakSet<object> | Set<object>;
-  knownReferencedNames: Set<string>;
-  imports: Map<string, Map<string, NonLocalImportSpecifier>>;
-  retryErrors: Array<{
-    fn: BabelFn;
-    error: CompilerError;
-  }>;
-  inferredEffectLocations: Set<t.SourceLocation>;
-  constructor({
-    program,
-    suppressions,
-    opts,
-    filename,
-    code,
-    hasModuleScopeOptOut,
-  }: ProgramContextOptions);
-  isHookName(name: string): boolean;
-  hasReference(name: string): boolean;
-  newUid(name: string): string;
-  addMemoCacheImport(): NonLocalImportSpecifier;
-  addImportSpecifier(
-    { source: module, importSpecifierName: specifier }: ExternalFunction,
-    nameHint?: string,
-  ): NonLocalImportSpecifier;
-  addNewReference(name: string): void;
-  assertGlobalBinding(
-    name: string,
-    localScope?: Scope,
-  ): Result<void, CompilerError>;
-  logEvent(event: LoggerEvent): void;
-}
-
-declare type ProgramContextOptions = {
-  program: NodePath<t.Program>;
-  suppressions: Array<SuppressionRange>;
-  opts: ParsedPluginOptions;
-  filename: string | null;
-  code: string | null;
-  hasModuleScopeOptOut: boolean;
-};
-
-declare type PromotedIdentifier = {
-  kind: "promoted";
-  value: string;
-};
-
-declare type PropertyLiteral = (string | number) & {
-  [opaquePropertyLiteral]: "PropertyLiteral";
-};
-
-declare type PropertyLoad = {
-  kind: "PropertyLoad";
-  object: Place;
-  property: PropertyLiteral;
-  loc: SourceLocation;
-};
-
-declare type PropType = {
-  kind: "Property";
-  objectType: Type;
-  objectName: string;
-  propertyName:
-    | {
-        kind: "literal";
-        value: PropertyLiteral;
-      }
-    | {
-        kind: "computed";
-        value: Type;
-      };
-};
-
-declare type PrunedReactiveScopeBlock = {
-  kind: "pruned-scope";
-  scope: ReactiveScope;
-  instructions: ReactiveBlock;
-};
-
-declare type PrunedScopeTerminal = {
-  kind: "pruned-scope";
-  fallthrough: BlockId;
-  block: BlockId;
-  scope: ReactiveScope;
-  id: InstructionId;
-  loc: SourceLocation;
-};
-
-declare type ReactFunctionType = "Component" | "Hook" | "Other";
-
-declare type ReactiveBlock = Array<ReactiveStatement>;
-
-declare type ReactiveBreakTerminal = {
-  kind: "break";
-  target: BlockId;
-  id: InstructionId;
-  targetKind: ReactiveTerminalTargetKind;
-  loc: SourceLocation;
-};
-
-declare type ReactiveContinueTerminal = {
-  kind: "continue";
-  target: BlockId;
-  id: InstructionId;
-  targetKind: ReactiveTerminalTargetKind;
-  loc: SourceLocation;
-};
-
-declare type ReactiveDoWhileTerminal = {
-  kind: "do-while";
-  loop: ReactiveBlock;
-  test: ReactiveValue;
-  id: InstructionId;
-  loc: SourceLocation;
-};
-
-declare type ReactiveForInTerminal = {
-  kind: "for-in";
-  init: ReactiveValue;
-  loop: ReactiveBlock;
-  id: InstructionId;
-  loc: SourceLocation;
-};
-
-declare type ReactiveForOfTerminal = {
-  kind: "for-of";
-  init: ReactiveValue;
-  test: ReactiveValue;
-  loop: ReactiveBlock;
-  id: InstructionId;
-  loc: SourceLocation;
-};
-
-declare type ReactiveForTerminal = {
-  kind: "for";
-  init: ReactiveValue;
-  test: ReactiveValue;
-  update: ReactiveValue | null;
-  loop: ReactiveBlock;
-  id: InstructionId;
-  loc: SourceLocation;
-};
-
-declare type ReactiveFunction = {
-  loc: SourceLocation;
-  id: ValidIdentifierName | null;
-  nameHint: string | null;
-  params: Array<Place | SpreadPattern>;
-  generator: boolean;
-  async: boolean;
-  body: ReactiveBlock;
-  env: Environment;
-  directives: Array<string>;
-};
-
-declare type ReactiveIfTerminal = {
-  kind: "if";
-  test: Place;
-  consequent: ReactiveBlock;
-  alternate: ReactiveBlock | null;
-  id: InstructionId;
-  loc: SourceLocation;
-};
-
-declare type ReactiveInstruction = {
-  id: InstructionId;
-  lvalue: Place | null;
-  value: ReactiveValue;
-  effects?: Array<AliasingEffect> | null;
-  loc: SourceLocation;
-};
-
-declare type ReactiveInstructionStatement = {
-  kind: "instruction";
-  instruction: ReactiveInstruction;
-};
-
-declare type ReactiveLabelTerminal = {
-  kind: "label";
-  block: ReactiveBlock;
-  id: InstructionId;
-  loc: SourceLocation;
-};
-
-declare type ReactiveLogicalValue = {
-  kind: "LogicalExpression";
-  operator: t.LogicalExpression["operator"];
-  left: ReactiveValue;
-  right: ReactiveValue;
-  loc: SourceLocation;
-};
-
-declare type ReactiveOptionalCallValue = {
-  kind: "OptionalExpression";
-  id: InstructionId;
-  value: ReactiveValue;
-  optional: boolean;
-  loc: SourceLocation;
-};
-
-declare type ReactiveReturnTerminal = {
-  kind: "return";
-  value: Place;
-  id: InstructionId;
-  loc: SourceLocation;
-};
-
-declare type ReactiveScope = {
-  id: ScopeId;
-  range: MutableRange;
-  dependencies: ReactiveScopeDependencies;
-  declarations: Map<IdentifierId, ReactiveScopeDeclaration>;
-  reassignments: Set<Identifier>;
-  earlyReturnValue: {
-    value: Identifier;
-    loc: SourceLocation;
-    label: BlockId;
-  } | null;
-  merged: Set<ScopeId>;
-  loc: SourceLocation;
-};
-
-declare type ReactiveScopeBlock = {
-  kind: "scope";
-  scope: ReactiveScope;
-  instructions: ReactiveBlock;
-};
-
-declare type ReactiveScopeDeclaration = {
-  identifier: Identifier;
-  scope: ReactiveScope;
-};
-
-declare type ReactiveScopeDependencies = Set<ReactiveScopeDependency>;
-
-declare type ReactiveScopeDependency = {
-  identifier: Identifier;
-  reactive: boolean;
-  path: DependencyPath;
-};
-
-declare type ReactiveScopeTerminal = {
-  kind: "scope";
-  fallthrough: BlockId;
-  block: BlockId;
-  scope: ReactiveScope;
-  id: InstructionId;
-  loc: SourceLocation;
-};
-
-declare type ReactiveSequenceValue = {
-  kind: "SequenceExpression";
-  instructions: Array<ReactiveInstruction>;
-  id: InstructionId;
-  value: ReactiveValue;
-  loc: SourceLocation;
-};
-
-declare type ReactiveStatement =
-  | ReactiveInstructionStatement
-  | ReactiveTerminalStatement
-  | ReactiveScopeBlock
-  | PrunedReactiveScopeBlock;
-
-declare type ReactiveSwitchTerminal = {
-  kind: "switch";
-  test: Place;
-  cases: Array<{
-    test: Place | null;
-    block: ReactiveBlock | void;
-  }>;
-  id: InstructionId;
-  loc: SourceLocation;
-};
-
-declare type ReactiveTerminal =
-  | ReactiveBreakTerminal
-  | ReactiveContinueTerminal
-  | ReactiveReturnTerminal
-  | ReactiveThrowTerminal
-  | ReactiveSwitchTerminal
-  | ReactiveDoWhileTerminal
-  | ReactiveWhileTerminal
-  | ReactiveForTerminal
-  | ReactiveForOfTerminal
-  | ReactiveForInTerminal
-  | ReactiveIfTerminal
-  | ReactiveLabelTerminal
-  | ReactiveTryTerminal;
-
-declare type ReactiveTerminalStatement<
-  Tterminal extends ReactiveTerminal = ReactiveTerminal,
-> = {
-  kind: "terminal";
-  terminal: Tterminal;
-  label: {
-    id: BlockId;
-    implicit: boolean;
-  } | null;
-};
-
-declare type ReactiveTerminalTargetKind = "implicit" | "labeled" | "unlabeled";
-
-declare type ReactiveTernaryValue = {
-  kind: "ConditionalExpression";
-  test: ReactiveValue;
-  consequent: ReactiveValue;
-  alternate: ReactiveValue;
-  loc: SourceLocation;
-};
-
-declare type ReactiveThrowTerminal = {
-  kind: "throw";
-  value: Place;
-  id: InstructionId;
-  loc: SourceLocation;
-};
-
-declare type ReactiveTryTerminal = {
-  kind: "try";
-  block: ReactiveBlock;
-  handlerBinding: Place | null;
-  handler: ReactiveBlock;
-  id: InstructionId;
-  loc: SourceLocation;
-};
-
-declare type ReactiveValue =
-  | InstructionValue
-  | ReactiveLogicalValue
-  | ReactiveSequenceValue
-  | ReactiveTernaryValue
-  | ReactiveOptionalCallValue;
-
-declare type ReactiveWhileTerminal = {
-  kind: "while";
-  test: ReactiveValue;
-  loop: ReactiveBlock;
-  id: InstructionId;
-  loc: SourceLocation;
-};
-
-declare type ResolvedType = {
-  kind: "Concrete";
-  type: ConcreteType<ResolvedType>;
-  platform: Platform;
-};
-
 /**
  * Resolves the relative entry paths for a Sanity project without writing any
  * runtime files to disk. Used by federation builds that skip the full runtime
@@ -2100,40 +105,9 @@ export declare function resolveEntries(options: {
   relativeEntry: string | null;
 }>;
 
-declare interface Result<T, E> {
-  map<U>(fn: (val: T) => U): Result<U, E>;
-  mapErr<F>(fn: (val: E) => F): Result<T, F>;
-  mapOr<U>(fallback: U, fn: (val: T) => U): U;
-  mapOrElse<U>(fallback: () => U, fn: (val: T) => U): U;
-  andThen<U>(fn: (val: T) => Result<U, E>): Result<U, E>;
-  and<U>(res: Result<U, E>): Result<U, E>;
-  or(res: Result<T, E>): Result<T, E>;
-  orElse<F>(fn: (val: E) => Result<T, F>): Result<T, F>;
-  isOk(): this is OkImpl<T>;
-  isErr(): this is ErrImpl<E>;
-  expect(msg: string): T;
-  expectErr(msg: string): E;
-  unwrap(): T;
-  unwrapOr(fallback: T): T;
-  unwrapOrElse(fallback: (val: E) => T): T;
-  unwrapErr(): E;
-}
-
-declare type ReturnTerminal = {
-  kind: "return";
-  returnVariant: ReturnVariant;
-  loc: SourceLocation;
-  value: Place;
-  id: InstructionId;
-  fallthrough?: never;
-  effects: Array<AliasingEffect> | null;
-};
-
-declare type ReturnVariant = "Void" | "Implicit" | "Explicit";
-
 declare interface RuntimeOptions {
   cwd: string;
-  reactStrictMode: boolean;
+  reactStrictMode: boolean | undefined;
   watch: boolean;
   appTitle?: string;
   basePath?: string;
@@ -2149,47 +123,6 @@ declare interface RuntimeOptions {
  */
 export declare const SANITY_CACHE_DIR = "node_modules/.sanity";
 
-declare type ScopeId = number & {
-  [opaqueScopeId]: "ScopeId";
-};
-
-declare type SequenceTerminal = {
-  kind: "sequence";
-  block: BlockId;
-  fallthrough: BlockId;
-  id: InstructionId;
-  loc: SourceLocation;
-};
-
-declare type SourceLocation = t.SourceLocation | typeof GeneratedSource;
-
-declare type SpreadPattern = {
-  kind: "Spread";
-  place: Place;
-};
-
-declare type StartMemoize = {
-  kind: "StartMemoize";
-  manualMemoId: number;
-  deps: Array<ManualMemoDependency> | null;
-  loc: SourceLocation;
-};
-
-declare type StoreGlobal = {
-  kind: "StoreGlobal";
-  name: string;
-  value: Place;
-  loc: SourceLocation;
-};
-
-declare type StoreLocal = {
-  kind: "StoreLocal";
-  lvalue: LValue;
-  value: Place;
-  type: t.FlowType | t.TSType | null;
-  loc: SourceLocation;
-};
-
 export declare const StudioBuildTrace: DefinedTelemetryTrace<
   {
     outputSize: number;
@@ -2197,157 +130,12 @@ export declare const StudioBuildTrace: DefinedTelemetryTrace<
   void
 >;
 
-declare type SuppressionRange = {
-  disableComment: t.Comment;
-  enableComment: t.Comment | null;
-  source: SuppressionSource;
-};
-
-declare type SuppressionSource = "Eslint" | "Flow";
-
-declare type SwitchTerminal = {
-  kind: "switch";
-  test: Place;
-  cases: Array<Case>;
-  fallthrough: BlockId;
-  id: InstructionId;
-  loc: SourceLocation;
-};
-
-declare type Terminal =
-  | UnsupportedTerminal
-  | UnreachableTerminal
-  | ThrowTerminal
-  | ReturnTerminal
-  | GotoTerminal
-  | IfTerminal
-  | BranchTerminal
-  | SwitchTerminal
-  | ForTerminal
-  | ForOfTerminal
-  | ForInTerminal
-  | DoWhileTerminal
-  | WhileTerminal
-  | LogicalTerminal
-  | TernaryTerminal
-  | OptionalTerminal
-  | LabelTerminal
-  | SequenceTerminal
-  | MaybeThrowTerminal
-  | TryTerminal
-  | ReactiveScopeTerminal
-  | PrunedScopeTerminal;
-
-declare type TernaryTerminal = {
-  kind: "ternary";
-  test: BlockId;
-  fallthrough: BlockId;
-  id: InstructionId;
-  loc: SourceLocation;
-};
-
-declare type ThrowTerminal = {
-  kind: "throw";
-  value: Place;
-  id: InstructionId;
-  loc: SourceLocation;
-  fallthrough?: never;
-};
-
-declare type TimingEvent = {
-  kind: "Timing";
-  measurement: PerformanceMeasure;
-};
-
 declare interface TrackedPackage {
   deprecatedBelow: string | null;
   name: string;
   supported: string[];
 }
 
-declare type TryTerminal = {
-  kind: "try";
-  block: BlockId;
-  handlerBinding: Place | null;
-  handler: BlockId;
-  fallthrough: BlockId;
-  id: InstructionId;
-  loc: SourceLocation;
-};
-
-declare type Type =
-  | BuiltInType
-  | PhiType
-  | TypeVar
-  | PolyType
-  | PropType
-  | ObjectMethod$1;
-
-declare type TypeId = number & {
-  [opaqueTypeId]: "IdentifierId";
-};
-
-declare type TypeParameter<T> = {
-  name: string;
-  id: TypeParameterId;
-  bound: T;
-};
-
-declare type TypeParameterId = number & {
-  [opaqueTypeParameterId]: "TypeParameterId";
-};
-
-declare type TypeVar = {
-  kind: "Type";
-  id: TypeId;
-};
-
-declare type UnreachableTerminal = {
-  kind: "unreachable";
-  id: InstructionId;
-  loc: SourceLocation;
-  fallthrough?: never;
-};
-
-declare type UnsupportedTerminal = {
-  kind: "unsupported";
-  id: InstructionId;
-  loc: SourceLocation;
-  fallthrough?: never;
-};
-
-declare type ValidatedIdentifier = {
-  kind: "named";
-  value: ValidIdentifierName;
-};
-
-declare type ValidIdentifierName = string & {
-  [opaqueValidIdentifierName]: "ValidIdentifierName";
-};
-
-declare enum ValueKind {
-  MaybeFrozen = "maybefrozen",
-  Frozen = "frozen",
-  Primitive = "primitive",
-  Global = "global",
-  Mutable = "mutable",
-  Context = "context",
-}
-
-declare enum ValueReason {
-  Global = "global",
-  JsxCaptured = "jsx-captured",
-  HookCaptured = "hook-captured",
-  HookReturn = "hook-return",
-  Effect = "effect",
-  KnownReturnSignature = "known-return-signature",
-  Context = "context",
-  State = "state",
-  ReducerState = "reducer-state",
-  ReactiveFunctionArgument = "reactive-function-argument",
-  Other = "other",
-}
-
 declare interface VendorBuildOptions {
   basePath: string;
   cwd: string;
@@ -2426,15 +214,6 @@ declare interface ViteOptions extends Pick<CliConfig, "schemaExtraction"> {
   views?: readonly InterfaceArtifact[];
 }
 
-declare type WhileTerminal = {
-  kind: "while";
-  loc: SourceLocation;
-  test: BlockId;
-  loop: BlockId;
-  fallthrough: BlockId;
-  id: InstructionId;
-};
-
 /**
  * @internal
  */